v.1.0.5

* update examplea and tests

Author: foo123

README.md

@@ -642,7 +642,7 @@ o.dispose()
 * support multivariate polynomial, multivariate operations **[DONE]**
 * implement groebner basis computations (`Buchberger` algorithm) **[DONE]**
 * support generic algebraic Rings and Fields (including rings of polynomials and fraction fields of polynomials) **[DONE]**
-* exact/symbolic `SVD` computation, faster numeric `SVD` computation (TODO)
+* faster numeric `SVD` computation (TODO)
 * implement `LLL` algorithm (TODO)
 * add efficient `rank`/`unrank` methods for `DerangementPermutation`, `InvolutionPermutation`, `ConnectedPermutation`, `Composition` & `Partition` (TODO)
 * full support for `colex` ordering `Composition` & `Partition` **[DONE PARTIALY]**

src/js/Abacus.js

@@ -3903,15 +3903,15 @@ function solvelinears( a, b, with_param )
     var symbol = is_string(with_param) && with_param.length ? with_param : 'z', apinv, bp, ns;
 
     if ( !is_instance(a, Matrix) ) a = Matrix(Ring.Q(), a);
-    else a = Matrix(a.ring.associatedField(), a);
+    else if ( !a.ring.isField() ) a = Matrix(a.ring.associatedField(), a);
     if ( !a.nr || !a.nc ) return null;
     b = Matrix(a.ring, b);
     apinv = a.ginv(); bp = apinv.mul(b);
     if ( true===with_param ) return bp.col(0); // least squares solution
     else if ( !a.mul(bp).equ(b) ) return null; // no solutions exist
     if ( false===with_param )
     {
-        // particular least-norm solution
+        // particular solution
         return bp.col(0);
     }
     else
@@ -3920,8 +3920,8 @@ function solvelinears( a, b, with_param )
         ns = Matrix.I(a.ring, bp.nr).sub(apinv.mul(a));
         return array(bp.nr, function(i){
             return Expr(array(ns.nc, function(j){
-                return MulTerm(SymbolTerm(with_param+'_'+(j+1)), ns.val[i][j]);
-            })).add(bp.val[j][0]);
+                return MulTerm(SymbolTerm(symbol+'_'+(j+1)), ns.val[i][j]);
+            })).add(bp.val[i][0]);
         });
     }
 }
@@ -6189,6 +6189,13 @@ Abacus.Math = {
         return solvepythag(Arithmetic.nums(a), with_param)
     }
     ,linears: function( a, b, with_param ) {
+        var ring = Ring.Q();
+        if ( !is_instance(a, Matrix) && !is_array(a) && !is_args(a) ) return null;
+        if ( is_instance(a, Matrix) && (!a.nr || !a.nc) ) return null;
+        if ( !is_instance(a, Matrix) && !a.length ) return null;
+        //a = is_instance(a, Matrix) ? a : a;
+        if ( !is_instance(b, Matrix) && !is_array(b) && !is_args(b) ) b = array(is_instance(a, Matrix) ? a.nr : a.length, function(){return b||0;});
+        b = is_instance(b, Matrix) ? b : ring.cast(b);
         return solvelinears( a, b, with_param );
     }
 

src/js/Abacus.min.js

@@ -1,4 +1,4 @@
-Abacus.Subsets via Abacus.Combinations (VERSION = 1.0.0)
+Abacus.Subsets via Abacus.Combinations (VERSION = 1.0.5)
 ---
 o = Abacus.CombinatorialIterator([Abacus.Combination(5,0),Abacus.Combination(5,1),Abacus.Combination(5,2),Abacus.Combination(5,3),Abacus.Combination(5,4),Abacus.Combination(5,5)])
 o.total()
@@ -243,38 +243,38 @@ o.order("colex,reversed")
 [ 0 ]
 []
 o.order("random")
+[ 2, 4 ]
+[ 3, 4 ]
+[ 2 ]
+[ 3 ]
+[ 1, 2, 3 ]
 [ 2, 3 ]
-[ 3, 2 ]
-[ 4 ]
-[ 0, 3, 4 ]
-[ 3, 2 ]
-[ 1 ]
+[ 0, 1, 4 ]
+[ 1, 2, 4 ]
+[ 0, 2, 3, 4 ]
 [ 2, 3, 4 ]
+[ 0, 1 ]
+[ 3, 4 ]
+[ 4, 0 ]
+[ 4 ]
+[ 3, 4 ]
+[ 0, 1, 2, 3, 4 ]
 [ 0, 1, 4 ]
-[ 3, 2 ]
-[ 0, 1, 3, 4 ]
-[ 1, 2, 3, 4 ]
+[ 3 ]
 [ 1 ]
-[ 0 ]
-[ 2, 1 ]
-[ 0, 1, 4 ]
 [ 0, 1, 4 ]
-[ 0, 3 ]
-[ 2, 3 ]
-[ 0, 3, 4 ]
 [ 3, 1 ]
-[ 2, 3 ]
-[ 0, 3, 4 ]
-[ 0, 1, 2, 3 ]
-[ 0, 1, 2, 3 ]
-[ 4, 1 ]
+[ 1, 2 ]
 [ 3, 4 ]
-[ 0, 1 ]
-[ 0, 1, 4 ]
+[ 0, 1, 2, 3, 4 ]
+[ 3, 1 ]
 [ 0, 2, 4 ]
-[ 1, 4 ]
+[ 1, 2 ]
+[ 2 ]
 [ 3, 4 ]
-[ 0, 1, 4 ]
+[ 0, 2, 4 ]
+[ 2, 3, 4 ]
+[ 2, 3, 4 ]
 o.random()
-[ 3 ]
+[ 1, 2, 3, 4 ]
 o.dispose()

test/combination_subsets.txt

@@ -1,4 +1,4 @@
-Abacus.Combinations (VERSION = 1.0.0)
+Abacus.Combinations (VERSION = 1.0.5)
 ---
 o = Abacus.Combination(6,3)
 o.total()
@@ -159,28 +159,28 @@ o.order("colex,reversed")
 [ 0, 1, 3 ]
 [ 0, 1, 2 ]
 o.order("random")
+[ 0, 1, 3 ]
+[ 2, 3, 4 ]
+[ 0, 1, 2 ]
+[ 1, 4, 5 ]
+[ 1, 2, 4 ]
+[ 0, 3, 5 ]
+[ 1, 3, 4 ]
 [ 0, 2, 5 ]
-[ 0, 1, 5 ]
+[ 2, 3, 5 ]
 [ 3, 4, 5 ]
-[ 0, 2, 3 ]
-[ 0, 2, 4 ]
 [ 0, 4, 5 ]
+[ 2, 4, 5 ]
 [ 0, 3, 4 ]
-[ 1, 2, 4 ]
-[ 0, 3, 5 ]
-[ 2, 3, 4 ]
-[ 0, 1, 4 ]
-[ 2, 3, 5 ]
 [ 1, 2, 3 ]
-[ 1, 2, 5 ]
-[ 1, 4, 5 ]
-[ 2, 4, 5 ]
 [ 1, 3, 5 ]
-[ 0, 1, 3 ]
-[ 0, 1, 2 ]
-[ 1, 3, 4 ]
+[ 1, 2, 5 ]
+[ 0, 2, 4 ]
+[ 0, 1, 4 ]
+[ 0, 1, 5 ]
+[ 0, 2, 3 ]
 o.random()
-[ 1, 2, 3 ]
+[ 2, 3, 4 ]
 o.order("colex").range(-5, -1)
 [ 2, 3, 5 ]
 [ 0, 4, 5 ]

test/combinations.txt

@@ -1,4 +1,4 @@
-Abacus.CombinationRepeats (VERSION = 1.0.0)
+Abacus.CombinationRepeats (VERSION = 1.0.5)
 ---
 o = Abacus.Combination(6,3,{type:"repeated"})
 o.total()
@@ -411,64 +411,64 @@ o.order("colex,reversed")
 [ 0, 0, 1 ]
 [ 0, 0, 0 ]
 o.order("random")
-[ 0, 2, 4 ]
-[ 0, 4, 4 ]
-[ 5, 5, 5 ]
-[ 3, 3, 4 ]
-[ 0, 2, 5 ]
-[ 1, 4, 5 ]
-[ 0, 0, 1 ]
+[ 2, 3, 3 ]
+[ 2, 3, 5 ]
+[ 3, 4, 5 ]
+[ 1, 4, 4 ]
+[ 2, 3, 4 ]
+[ 1, 1, 5 ]
+[ 1, 2, 4 ]
+[ 0, 1, 1 ]
+[ 1, 3, 5 ]
 [ 0, 3, 4 ]
-[ 3, 3, 3 ]
-[ 2, 5, 5 ]
-[ 0, 0, 0 ]
-[ 1, 1, 2 ]
-[ 2, 2, 2 ]
-[ 0, 0, 5 ]
+[ 4, 5, 5 ]
+[ 1, 2, 5 ]
+[ 0, 2, 2 ]
 [ 3, 3, 5 ]
-[ 2, 2, 4 ]
+[ 0, 4, 5 ]
+[ 0, 0, 5 ]
+[ 0, 3, 5 ]
+[ 1, 1, 4 ]
+[ 0, 0, 1 ]
 [ 0, 1, 3 ]
-[ 0, 3, 3 ]
-[ 3, 4, 4 ]
-[ 1, 5, 5 ]
+[ 1, 2, 3 ]
+[ 1, 4, 5 ]
+[ 2, 2, 3 ]
+[ 1, 2, 2 ]
+[ 3, 5, 5 ]
 [ 0, 2, 3 ]
-[ 0, 2, 2 ]
-[ 0, 1, 4 ]
-[ 1, 1, 1 ]
-[ 1, 1, 4 ]
-[ 4, 4, 5 ]
-[ 2, 3, 3 ]
-[ 1, 2, 4 ]
-[ 1, 3, 4 ]
-[ 2, 4, 4 ]
-[ 3, 4, 5 ]
-[ 2, 4, 5 ]
-[ 0, 3, 5 ]
-[ 0, 5, 5 ]
+[ 3, 3, 4 ]
+[ 0, 3, 3 ]
 [ 2, 2, 5 ]
-[ 4, 5, 5 ]
-[ 0, 1, 2 ]
-[ 1, 3, 3 ]
-[ 1, 1, 3 ]
+[ 0, 0, 3 ]
 [ 0, 0, 2 ]
-[ 2, 3, 5 ]
-[ 0, 1, 1 ]
+[ 0, 1, 4 ]
+[ 0, 1, 2 ]
+[ 2, 2, 4 ]
+[ 2, 5, 5 ]
+[ 1, 5, 5 ]
+[ 5, 5, 5 ]
+[ 0, 0, 0 ]
 [ 0, 0, 4 ]
-[ 0, 0, 3 ]
-[ 3, 5, 5 ]
-[ 0, 1, 5 ]
-[ 1, 2, 5 ]
-[ 1, 1, 5 ]
-[ 2, 3, 4 ]
-[ 1, 2, 2 ]
-[ 2, 2, 3 ]
-[ 1, 4, 4 ]
-[ 0, 4, 5 ]
-[ 1, 2, 3 ]
+[ 1, 3, 3 ]
+[ 2, 2, 2 ]
 [ 4, 4, 4 ]
-[ 1, 3, 5 ]
-o.random()
+[ 1, 3, 4 ]
+[ 0, 1, 5 ]
+[ 1, 1, 3 ]
+[ 2, 4, 4 ]
+[ 0, 5, 5 ]
+[ 3, 3, 3 ]
 [ 0, 2, 4 ]
+[ 4, 4, 5 ]
+[ 3, 4, 4 ]
+[ 1, 1, 2 ]
+[ 0, 2, 5 ]
+[ 1, 1, 1 ]
+[ 2, 4, 5 ]
+[ 0, 4, 4 ]
+o.random()
+[ 0, 2, 3 ]
 o.order("colex").range(-5, -1)
 [ 1, 5, 5 ]
 [ 2, 5, 5 ]

test/combinations_repeats.txt

@@ -1,4 +1,4 @@
-Abacus.Complex (VERSION = 1.0.0)
+Abacus.Complex (VERSION = 1.0.5)
 ---
 o=Abacus.Complex()
 o.toString()
@@ -10,11 +10,11 @@ o.toDec()
 
 o=Abacus.Complex.rnd("0", "1+i")
 o.toString()
-1/2+(221/256)*i
+(1/32)*i
 o.toDec()
-0.5+0.86328125i
+0.03125i
 o.rad(2).toString()
-4329443362913/5003173903488+(1438256679137/2883370983552)*i
+1/8+(1/8)*i
 
 Abacus.Complex(1).rad(2)
 1

test/complex.txt

@@ -37,7 +37,9 @@ echo(o.next());
 
 echo('default order is "lex", lexicographic-order');
 echo('o.rewind()');
-print_all( o.rewind() );
+print_all( o.rewind(), 1, function( item ){
+    return [item.slice(), o.index()-(o.hasNext()?1:0), Abacus.Partition.rank(item, o.n, o.$)];
+});
 
 echo('backwards');
 echo('o.rewind(-1)');
@@ -82,7 +84,9 @@ echo(o.next());
 
 echo('default order is "lex", lexicographic-order');
 echo('o.rewind()');
-print_all( o.rewind() );
+print_all( o.rewind(), 1, function( item ){
+    return [item.slice(), o.index()-(o.hasNext()?1:0), Abacus.Partition.rank(item, o.n, o.$)];
+});
 
 echo('backwards');
 echo('o.rewind(-1)');
@@ -120,7 +124,9 @@ echo(o.next());
 
 echo('default order is "lex", lexicographic-order');
 echo('o.rewind()');
-print_all( o.rewind() );
+print_all( o.rewind(), 1, function( item ){
+    return [item.slice(), o.index()-(o.hasNext()?1:0), Abacus.Partition.rank(item, o.n, o.$)];
+});
 
 echo('backwards');
 echo('o.rewind(-1)');