diff options
author | Karl Berry <karl@freefriends.org> | 2010-07-05 22:26:04 +0000 |
---|---|---|
committer | Karl Berry <karl@freefriends.org> | 2010-07-05 22:26:04 +0000 |
commit | 648027bec248a7b000741a507b507f6d89941ce5 (patch) | |
tree | ce3b82b43a8b17403eda43db782bbf2e5bf0e161 /Build/source/utils/asymptote/runarray.cc | |
parent | 5ff8f96c8ab3bd3aeb8fed8d512c57134fb2a6cc (diff) |
asy 2.00
git-svn-id: svn://tug.org/texlive/trunk@19250 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/utils/asymptote/runarray.cc')
-rw-r--r-- | Build/source/utils/asymptote/runarray.cc | 413 |
1 files changed, 207 insertions, 206 deletions
diff --git a/Build/source/utils/asymptote/runarray.cc b/Build/source/utils/asymptote/runarray.cc index 97df85c93d1..85f5f2c1d84 100644 --- a/Build/source/utils/asymptote/runarray.cc +++ b/Build/source/utils/asymptote/runarray.cc @@ -656,13 +656,14 @@ void arrayArrayRead(stack *Stack) } // Write an element to an array. Increase size if necessary. -#line 567 "runarray.in" +// TODO: Add arrayWriteAndPop +#line 568 "runarray.in" void arrayWrite(stack *Stack) { + item value=vm::pop(Stack); Int n=vm::pop<Int>(Stack); array * a=vm::pop<array *>(Stack); - item value=vm::pop(Stack); -#line 568 "runarray.in" +#line 569 "runarray.in" size_t len=checkArray(a); bool cyclic=a->cyclic(); if(cyclic && len > 0) n=imod(n,len); @@ -676,27 +677,27 @@ void arrayWrite(stack *Stack) {Stack->push(value); return;} } -#line 582 "runarray.in" +#line 583 "runarray.in" void arraySliceWrite(stack *Stack) { + array * src=vm::pop<array *>(Stack); Int right=vm::pop<Int>(Stack); Int left=vm::pop<Int>(Stack); array * dest=vm::pop<array *>(Stack); - array * src=vm::pop<array *>(Stack); -#line 583 "runarray.in" +#line 584 "runarray.in" checkArray(src); checkArray(dest); dest->setSlice(left, right, src); {Stack->push<array*>(src); return;} } -#line 590 "runarray.in" +#line 591 "runarray.in" void arraySliceWriteToEnd(stack *Stack) { + array * src=vm::pop<array *>(Stack); Int left=vm::pop<Int>(Stack); array * dest=vm::pop<array *>(Stack); - array * src=vm::pop<array *>(Stack); -#line 591 "runarray.in" +#line 592 "runarray.in" checkArray(src); size_t len=checkArray(dest); dest->setSlice(left, (Int) len, src); @@ -704,20 +705,20 @@ void arraySliceWriteToEnd(stack *Stack) } // Returns the length of an array. -#line 599 "runarray.in" +#line 600 "runarray.in" void arrayLength(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 600 "runarray.in" +#line 601 "runarray.in" {Stack->push<Int>((Int) checkArray(a)); return;} } // Returns an array of integers representing the keys of the array. -#line 605 "runarray.in" +#line 606 "runarray.in" void arrayKeys(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 606 "runarray.in" +#line 607 "runarray.in" size_t size=checkArray(a); array *keys=new array(); @@ -731,33 +732,33 @@ void arrayKeys(stack *Stack) } // Return the cyclic flag for an array. -#line 620 "runarray.in" +#line 621 "runarray.in" void arrayCyclicFlag(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 621 "runarray.in" +#line 622 "runarray.in" checkArray(a); {Stack->push<bool>(a->cyclic()); return;} } -#line 626 "runarray.in" +#line 627 "runarray.in" void arraySetCyclicFlag(stack *Stack) { array * a=vm::pop<array *>(Stack); bool b=vm::pop<bool>(Stack); -#line 627 "runarray.in" +#line 628 "runarray.in" checkArray(a); a->cyclic(b); {Stack->push<bool>(b); return;} } // Check to see if an array element is initialized. -#line 634 "runarray.in" +#line 635 "runarray.in" void arrayInitializedHelper(stack *Stack) { array * a=vm::pop<array *>(Stack); Int n=vm::pop<Int>(Stack); -#line 635 "runarray.in" +#line 636 "runarray.in" size_t len=checkArray(a); bool cyclic=a->cyclic(); if(cyclic && len > 0) n=imod(n,len); @@ -767,62 +768,62 @@ void arrayInitializedHelper(stack *Stack) } // Returns the initialize method for an array. -#line 645 "runarray.in" +#line 646 "runarray.in" void arrayInitialized(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 646 "runarray.in" +#line 647 "runarray.in" {Stack->push<callable*>(new thunk(new bfunc(arrayInitializedHelper),a)); return;} } // The helper function for the cyclic method that sets the cyclic flag. -#line 651 "runarray.in" +#line 652 "runarray.in" void arrayCyclicHelper(stack *Stack) { array * a=vm::pop<array *>(Stack); bool b=vm::pop<bool>(Stack); -#line 652 "runarray.in" +#line 653 "runarray.in" checkArray(a); a->cyclic(b); } // Set the cyclic flag for an array. -#line 658 "runarray.in" +#line 659 "runarray.in" void arrayCyclic(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 659 "runarray.in" +#line 660 "runarray.in" {Stack->push<callable*>(new thunk(new bfunc(arrayCyclicHelper),a)); return;} } // The helper function for the push method that does the actual operation. -#line 664 "runarray.in" +#line 665 "runarray.in" void arrayPushHelper(stack *Stack) { array * a=vm::pop<array *>(Stack); item x=vm::pop(Stack); -#line 665 "runarray.in" +#line 666 "runarray.in" checkArray(a); a->push(x); {Stack->push(x); return;} } // Returns the push method for an array. -#line 672 "runarray.in" +#line 673 "runarray.in" void arrayPush(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 673 "runarray.in" +#line 674 "runarray.in" {Stack->push<callable*>(new thunk(new bfunc(arrayPushHelper),a)); return;} } // The helper function for the append method that appends b to a. -#line 678 "runarray.in" +#line 679 "runarray.in" void arrayAppendHelper(stack *Stack) { array * a=vm::pop<array *>(Stack); array * b=vm::pop<array *>(Stack); -#line 679 "runarray.in" +#line 680 "runarray.in" checkArray(a); size_t size=checkArray(b); for(size_t i=0; i < size; i++) @@ -830,20 +831,20 @@ void arrayAppendHelper(stack *Stack) } // Returns the append method for an array. -#line 687 "runarray.in" +#line 688 "runarray.in" void arrayAppend(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 688 "runarray.in" +#line 689 "runarray.in" {Stack->push<callable*>(new thunk(new bfunc(arrayAppendHelper),a)); return;} } // The helper function for the pop method. -#line 693 "runarray.in" +#line 694 "runarray.in" void arrayPopHelper(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 694 "runarray.in" +#line 695 "runarray.in" size_t asize=checkArray(a); if(asize == 0) error("cannot pop element from empty array"); @@ -851,22 +852,22 @@ void arrayPopHelper(stack *Stack) } // Returns the pop method for an array. -#line 702 "runarray.in" +#line 703 "runarray.in" void arrayPop(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 703 "runarray.in" +#line 704 "runarray.in" {Stack->push<callable*>(new thunk(new bfunc(arrayPopHelper),a)); return;} } // The helper function for the insert method. -#line 708 "runarray.in" +#line 709 "runarray.in" void arrayInsertHelper(stack *Stack) { array * a=vm::pop<array *>(Stack); array * x=vm::pop<array *>(Stack); Int i=vm::pop<Int>(Stack); -#line 709 "runarray.in" +#line 710 "runarray.in" size_t asize=checkArray(a); checkArray(x); if(a->cyclic() && asize > 0) i=imod(i,asize); @@ -876,39 +877,39 @@ void arrayInsertHelper(stack *Stack) } // Returns the insert method for an array. -#line 719 "runarray.in" +#line 720 "runarray.in" void arrayInsert(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 720 "runarray.in" +#line 721 "runarray.in" {Stack->push<callable*>(new thunk(new bfunc(arrayInsertHelper),a)); return;} } // Returns the delete method for an array. -#line 725 "runarray.in" +#line 726 "runarray.in" void arrayDelete(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 726 "runarray.in" +#line 727 "runarray.in" {Stack->push<callable*>(new thunk(new bfunc(arrayDeleteHelper),a)); return;} } -#line 730 "runarray.in" +#line 731 "runarray.in" void arrayAlias(stack *Stack) { array * b=vm::pop<array *>(Stack); array * a=vm::pop<array *>(Stack); -#line 731 "runarray.in" +#line 732 "runarray.in" {Stack->push<bool>(a==b); return;} } // Return array formed by indexing array a with elements of integer array b -#line 736 "runarray.in" +#line 737 "runarray.in" void arrayIntArray(stack *Stack) { array * b=vm::pop<array *>(Stack); array * a=vm::pop<array *>(Stack); -#line 737 "runarray.in" +#line 738 "runarray.in" size_t asize=checkArray(a); size_t bsize=checkArray(b); array *r=new array(bsize); @@ -926,13 +927,13 @@ void arrayIntArray(stack *Stack) // returns the complement of the integer array a in {0,2,...,n-1}, // so that b[complement(a,b.length)] yields the complement of b[a]. -#line 755 "runarray.in" +#line 756 "runarray.in" // Intarray* complement(Intarray *a, Int n); void gen_runarray33(stack *Stack) { Int n=vm::pop<Int>(Stack); Intarray * a=vm::pop<Intarray *>(Stack); -#line 756 "runarray.in" +#line 757 "runarray.in" size_t asize=checkArray(a); array *r=new array(0); bool *keep=new bool[n]; @@ -949,12 +950,12 @@ void gen_runarray33(stack *Stack) } // Generate the sequence {f(i) : i=0,1,...n-1} given a function f and integer n -#line 773 "runarray.in" +#line 774 "runarray.in" void arraySequence(stack *Stack) { Int n=vm::pop<Int>(Stack); callable * f=vm::pop<callable *>(Stack); -#line 774 "runarray.in" +#line 775 "runarray.in" if(n < 0) n=0; array *a=new array(n); for(Int i=0; i < n; ++i) { @@ -966,12 +967,12 @@ void arraySequence(stack *Stack) } // Return the array {0,1,...n-1} -#line 786 "runarray.in" +#line 787 "runarray.in" // Intarray* sequence(Int n); void gen_runarray35(stack *Stack) { Int n=vm::pop<Int>(Stack); -#line 787 "runarray.in" +#line 788 "runarray.in" if(n < 0) n=0; array *a=new array(n); for(Int i=0; i < n; ++i) { @@ -981,12 +982,12 @@ void gen_runarray35(stack *Stack) } // Apply a function to each element of an array -#line 797 "runarray.in" +#line 798 "runarray.in" void arrayFunction(stack *Stack) { array * a=vm::pop<array *>(Stack); callable * f=vm::pop<callable *>(Stack); -#line 798 "runarray.in" +#line 799 "runarray.in" size_t size=checkArray(a); array *b=new array(size); for(size_t i=0; i < size; ++i) { @@ -997,12 +998,12 @@ void arrayFunction(stack *Stack) {Stack->push<array*>(b); return;} } -#line 809 "runarray.in" +#line 810 "runarray.in" void arraySort(stack *Stack) { callable * less=vm::pop<callable *>(Stack); array * a=vm::pop<array *>(Stack); -#line 810 "runarray.in" +#line 811 "runarray.in" array *c=copyArray(a); compareFunc=less; FuncStack=Stack; @@ -1010,13 +1011,13 @@ void arraySort(stack *Stack) {Stack->push<array*>(c); return;} } -#line 818 "runarray.in" +#line 819 "runarray.in" void arraySearch(stack *Stack) { callable * less=vm::pop<callable *>(Stack); item key=vm::pop(Stack); array * a=vm::pop<array *>(Stack); -#line 819 "runarray.in" +#line 820 "runarray.in" size_t size=a->size(); compareFunc=less; FuncStack=Stack; @@ -1034,12 +1035,12 @@ void arraySearch(stack *Stack) {Stack->push<Int>(0); return;} } -#line 837 "runarray.in" +#line 838 "runarray.in" // bool all(boolarray *a); void gen_runarray39(stack *Stack) { boolarray * a=vm::pop<boolarray *>(Stack); -#line 838 "runarray.in" +#line 839 "runarray.in" size_t size=checkArray(a); bool c=true; for(size_t i=0; i < size; i++) @@ -1047,12 +1048,12 @@ void gen_runarray39(stack *Stack) {Stack->push<bool>(c); return;} } -#line 846 "runarray.in" +#line 847 "runarray.in" // boolarray* !(boolarray* a); void gen_runarray40(stack *Stack) { boolarray* a=vm::pop<boolarray*>(Stack); -#line 847 "runarray.in" +#line 848 "runarray.in" size_t size=checkArray(a); array *c=new array(size); for(size_t i=0; i < size; i++) @@ -1060,12 +1061,12 @@ void gen_runarray40(stack *Stack) {Stack->push<boolarray*>(c); return;} } -#line 855 "runarray.in" +#line 856 "runarray.in" // Int sum(boolarray *a); void gen_runarray41(stack *Stack) { boolarray * a=vm::pop<boolarray *>(Stack); -#line 856 "runarray.in" +#line 857 "runarray.in" size_t size=checkArray(a); Int sum=0; for(size_t i=0; i < size; i++) @@ -1073,19 +1074,19 @@ void gen_runarray41(stack *Stack) {Stack->push<Int>(sum); return;} } -#line 864 "runarray.in" +#line 865 "runarray.in" void arrayCopy(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 865 "runarray.in" +#line 866 "runarray.in" {Stack->push<array*>(copyArray(a)); return;} } -#line 869 "runarray.in" +#line 870 "runarray.in" void arrayConcat(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 870 "runarray.in" +#line 871 "runarray.in" // a is an array of arrays to be concatenated together. // The signature is // T[] concat(... T[][] a); @@ -1112,27 +1113,27 @@ void arrayConcat(stack *Stack) {Stack->push<array*>(result); return;} } -#line 897 "runarray.in" +#line 898 "runarray.in" void array2Copy(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 898 "runarray.in" +#line 899 "runarray.in" {Stack->push<array*>(copyArray2(a)); return;} } -#line 902 "runarray.in" +#line 903 "runarray.in" void array3Copy(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 903 "runarray.in" +#line 904 "runarray.in" {Stack->push<array*>(copyArray3(a)); return;} } -#line 907 "runarray.in" +#line 908 "runarray.in" void array2Transpose(stack *Stack) { array * a=vm::pop<array *>(Stack); -#line 908 "runarray.in" +#line 909 "runarray.in" size_t asize=checkArray(a); array *c=new array(0); for(size_t i=0; i < asize; i++) { @@ -1159,12 +1160,12 @@ void array2Transpose(stack *Stack) // permutation (021 or 120, etc; original is 012). // Transpose by sending respective members to the permutated locations: // return the array obtained by putting a[i][j][k] into position perm{ijk}. -#line 935 "runarray.in" +#line 936 "runarray.in" void array3Transpose(stack *Stack) { array * perm=vm::pop<array *>(Stack); array * a=vm::pop<array *>(Stack); -#line 936 "runarray.in" +#line 937 "runarray.in" const size_t DIM=3; if(checkArray(perm) != DIM) { @@ -1248,13 +1249,13 @@ void array3Transpose(stack *Stack) // In a boolean array, find the index of the nth true value or -1 if not found // If n is negative, search backwards. -#line 1020 "runarray.in" +#line 1021 "runarray.in" // Int find(boolarray *a, Int n=1); void gen_runarray48(stack *Stack) { Int n=vm::pop<Int>(Stack,1); boolarray * a=vm::pop<boolarray *>(Stack); -#line 1021 "runarray.in" +#line 1022 "runarray.in" size_t size=checkArray(a); Int j=-1; if(n > 0) @@ -1272,13 +1273,13 @@ void gen_runarray48(stack *Stack) // construct vector obtained by replacing those elements of b for which the // corresponding elements of a are false by the corresponding element of c. -#line 1039 "runarray.in" +#line 1040 "runarray.in" void arrayConditional(stack *Stack) { array * c=vm::pop<array *>(Stack); array * b=vm::pop<array *>(Stack); array * a=vm::pop<array *>(Stack); -#line 1040 "runarray.in" +#line 1041 "runarray.in" size_t size=checkArray(a); array *r=new array(size); if(b && c) { @@ -1302,22 +1303,22 @@ void arrayConditional(stack *Stack) } // Return an n x n identity matrix. -#line 1064 "runarray.in" +#line 1065 "runarray.in" // realarray2* identity(Int n); void gen_runarray50(stack *Stack) { Int n=vm::pop<Int>(Stack); -#line 1065 "runarray.in" +#line 1066 "runarray.in" {Stack->push<realarray2*>(Identity(n)); return;} } // Return the inverse of an n x n matrix a using Gauss-Jordan elimination. -#line 1070 "runarray.in" +#line 1071 "runarray.in" // realarray2* inverse(realarray2 *a); void gen_runarray51(stack *Stack) { realarray2 * a=vm::pop<realarray2 *>(Stack); -#line 1071 "runarray.in" +#line 1072 "runarray.in" a=copyArray2(a); size_t n=checkArray(a); checkSquare(a); @@ -1410,14 +1411,14 @@ void gen_runarray51(stack *Stack) // Solve the linear equation ax=b by LU decomposition, returning the // solution x, where a is an n x n matrix and b is an array of length n. // If no solution exists, return an empty array. -#line 1164 "runarray.in" +#line 1165 "runarray.in" // realarray* solve(realarray2 *a, realarray *b, bool warn=true); void gen_runarray52(stack *Stack) { bool warn=vm::pop<bool>(Stack,true); realarray * b=vm::pop<realarray *>(Stack); realarray2 * a=vm::pop<realarray2 *>(Stack); -#line 1165 "runarray.in" +#line 1166 "runarray.in" size_t n=checkArray(a); if(n == 0) {Stack->push<realarray*>(new array(0)); return;} @@ -1469,14 +1470,14 @@ void gen_runarray52(stack *Stack) // Solve the linear equation ax=b by LU decomposition, returning the // solution x, where a is an n x n matrix and b is an n x m matrix. // If no solution exists, return an empty array. -#line 1217 "runarray.in" +#line 1218 "runarray.in" // realarray2* solve(realarray2 *a, realarray2 *b, bool warn=true); void gen_runarray53(stack *Stack) { bool warn=vm::pop<bool>(Stack,true); realarray2 * b=vm::pop<realarray2 *>(Stack); realarray2 * a=vm::pop<realarray2 *>(Stack); -#line 1218 "runarray.in" +#line 1219 "runarray.in" size_t n=checkArray(a); if(n == 0) {Stack->push<realarray2*>(new array(0)); return;} @@ -1538,12 +1539,12 @@ void gen_runarray53(stack *Stack) } // Compute the determinant of an n x n matrix. -#line 1280 "runarray.in" +#line 1281 "runarray.in" // real determinant(realarray2 *a); void gen_runarray54(stack *Stack) { realarray2 * a=vm::pop<realarray2 *>(Stack); -#line 1281 "runarray.in" +#line 1282 "runarray.in" real *A; copyArray2C(A,a); size_t n=checkArray(a); @@ -1558,13 +1559,13 @@ void gen_runarray54(stack *Stack) {Stack->push<real>(det); return;} } -#line 1296 "runarray.in" +#line 1297 "runarray.in" // realarray* *(realarray2 *a, realarray *b); void gen_runarray55(stack *Stack) { realarray * b=vm::pop<realarray *>(Stack); realarray2 * a=vm::pop<realarray2 *>(Stack); -#line 1297 "runarray.in" +#line 1298 "runarray.in" size_t n=checkArray(a); size_t m=checkArray(b); array *c=new array(n); @@ -1582,13 +1583,13 @@ void gen_runarray55(stack *Stack) {Stack->push<realarray*>(c); return;} } -#line 1315 "runarray.in" +#line 1316 "runarray.in" // realarray* *(realarray *a, realarray2 *b); void gen_runarray56(stack *Stack) { realarray2 * b=vm::pop<realarray2 *>(Stack); realarray * a=vm::pop<realarray *>(Stack); -#line 1316 "runarray.in" +#line 1317 "runarray.in" size_t n=checkArray(a); if(n != checkArray(b)) error(incommensurate); real *A; @@ -1616,53 +1617,53 @@ void gen_runarray56(stack *Stack) {Stack->push<realarray*>(c); return;} } -#line 1344 "runarray.in" +#line 1345 "runarray.in" // Intarray2* *(Intarray2 *a, Intarray2 *b); void gen_runarray57(stack *Stack) { Intarray2 * b=vm::pop<Intarray2 *>(Stack); Intarray2 * a=vm::pop<Intarray2 *>(Stack); -#line 1345 "runarray.in" +#line 1346 "runarray.in" {Stack->push<Intarray2*>(mult<Int>(a,b)); return;} } -#line 1349 "runarray.in" +#line 1350 "runarray.in" // realarray2* *(realarray2 *a, realarray2 *b); void gen_runarray58(stack *Stack) { realarray2 * b=vm::pop<realarray2 *>(Stack); realarray2 * a=vm::pop<realarray2 *>(Stack); -#line 1350 "runarray.in" +#line 1351 "runarray.in" {Stack->push<realarray2*>(mult<real>(a,b)); return;} } -#line 1354 "runarray.in" +#line 1355 "runarray.in" // pairarray2* *(pairarray2 *a, pairarray2 *b); void gen_runarray59(stack *Stack) { pairarray2 * b=vm::pop<pairarray2 *>(Stack); pairarray2 * a=vm::pop<pairarray2 *>(Stack); -#line 1355 "runarray.in" +#line 1356 "runarray.in" {Stack->push<pairarray2*>(mult<pair>(a,b)); return;} } -#line 1359 "runarray.in" +#line 1360 "runarray.in" // triple *(realarray2 *t, triple v); void gen_runarray60(stack *Stack) { triple v=vm::pop<triple>(Stack); realarray2 * t=vm::pop<realarray2 *>(Stack); -#line 1360 "runarray.in" +#line 1361 "runarray.in" {Stack->push<triple>(*t*v); return;} } -#line 1364 "runarray.in" +#line 1365 "runarray.in" // pair project(triple v, realarray2 *t); void gen_runarray61(stack *Stack) { realarray2 * t=vm::pop<realarray2 *>(Stack); triple v=vm::pop<triple>(Stack); -#line 1365 "runarray.in" +#line 1366 "runarray.in" size_t n=checkArray(t); if(n != 4) error(incommensurate); array *t0=read<array*>(t,0); @@ -1687,13 +1688,13 @@ void gen_runarray61(stack *Stack) } // Compute the dot product of vectors a and b. -#line 1390 "runarray.in" +#line 1391 "runarray.in" // real dot(realarray *a, realarray *b); void gen_runarray62(stack *Stack) { realarray * b=vm::pop<realarray *>(Stack); realarray * a=vm::pop<realarray *>(Stack); -#line 1391 "runarray.in" +#line 1392 "runarray.in" size_t n=checkArrays(a,b); real sum=0.0; for(size_t i=0; i < n; ++i) @@ -1702,13 +1703,13 @@ void gen_runarray62(stack *Stack) } // Compute the complex dot product of vectors a and b. -#line 1400 "runarray.in" +#line 1401 "runarray.in" // pair dot(pairarray *a, pairarray *b); void gen_runarray63(stack *Stack) { pairarray * b=vm::pop<pairarray *>(Stack); pairarray * a=vm::pop<pairarray *>(Stack); -#line 1401 "runarray.in" +#line 1402 "runarray.in" size_t n=checkArrays(a,b); pair sum=zero; for(size_t i=0; i < n; ++i) @@ -1723,7 +1724,7 @@ void gen_runarray63(stack *Stack) // [ a[2] b[2] c[2] ] // [ ... ] // [ c[n-1] a[n-1] b[n-1] ] -#line 1416 "runarray.in" +#line 1417 "runarray.in" // realarray* tridiagonal(realarray *a, realarray *b, realarray *c, realarray *f); void gen_runarray64(stack *Stack) { @@ -1731,7 +1732,7 @@ void gen_runarray64(stack *Stack) realarray * c=vm::pop<realarray *>(Stack); realarray * b=vm::pop<realarray *>(Stack); realarray * a=vm::pop<realarray *>(Stack); -#line 1417 "runarray.in" +#line 1418 "runarray.in" size_t n=checkArrays(a,b); checkEqual(n,checkArray(c)); checkEqual(n,checkArray(f)); @@ -1828,7 +1829,7 @@ void gen_runarray64(stack *Stack) } // Root solve by Newton-Raphson -#line 1514 "runarray.in" +#line 1515 "runarray.in" // real newton(Int iterations=100, callableReal *f, callableReal *fprime, real x, bool verbose=false); void gen_runarray65(stack *Stack) { @@ -1837,7 +1838,7 @@ void gen_runarray65(stack *Stack) callableReal * fprime=vm::pop<callableReal *>(Stack); callableReal * f=vm::pop<callableReal *>(Stack); Int iterations=vm::pop<Int>(Stack,100); -#line 1516 "runarray.in" +#line 1517 "runarray.in" static const real fuzz=1000.0*DBL_EPSILON; Int i=0; size_t oldPrec=0; @@ -1883,7 +1884,7 @@ void gen_runarray65(stack *Stack) // Root solve by Newton-Raphson bisection // cf. routine rtsafe (Press et al., Numerical Recipes, 1991). -#line 1562 "runarray.in" +#line 1563 "runarray.in" // real newton(Int iterations=100, callableReal *f, callableReal *fprime, real x1, real x2, bool verbose=false); void gen_runarray66(stack *Stack) { @@ -1893,7 +1894,7 @@ void gen_runarray66(stack *Stack) callableReal * fprime=vm::pop<callableReal *>(Stack); callableReal * f=vm::pop<callableReal *>(Stack); Int iterations=vm::pop<Int>(Stack,100); -#line 1564 "runarray.in" +#line 1565 "runarray.in" static const real fuzz=1000.0*DBL_EPSILON; size_t oldPrec=0; if(verbose) @@ -1971,7 +1972,7 @@ void gen_runarray66(stack *Stack) {Stack->push<real>((j == iterations) ? DBL_MAX : x); return;} } -#line 1642 "runarray.in" +#line 1643 "runarray.in" // real simpson(callableReal *f, real a, real b, real acc=DBL_EPSILON, real dxmax=0); void gen_runarray67(stack *Stack) { @@ -1980,7 +1981,7 @@ void gen_runarray67(stack *Stack) real b=vm::pop<real>(Stack); real a=vm::pop<real>(Stack); callableReal * f=vm::pop<callableReal *>(Stack); -#line 1644 "runarray.in" +#line 1645 "runarray.in" real integral; if(dxmax <= 0) dxmax=fabs(b-a); Func=f; @@ -1991,13 +1992,13 @@ void gen_runarray67(stack *Stack) } // Compute the fast Fourier transform of a pair array -#line 1655 "runarray.in" +#line 1656 "runarray.in" // pairarray* fft(pairarray *a, Int sign=1); void gen_runarray68(stack *Stack) { Int sign=vm::pop<Int>(Stack,1); pairarray * a=vm::pop<pairarray *>(Stack); -#line 1656 "runarray.in" +#line 1657 "runarray.in" unsigned n=(unsigned) checkArray(a); #ifdef HAVE_LIBFFTW3 array *c=new array(n); @@ -2026,12 +2027,12 @@ void gen_runarray68(stack *Stack) {Stack->push<pairarray*>(c); return;} } -#line 1685 "runarray.in" +#line 1686 "runarray.in" // Intarray2* triangulate(pairarray *z); void gen_runarray69(stack *Stack) { pairarray * z=vm::pop<pairarray *>(Stack); -#line 1686 "runarray.in" +#line 1687 "runarray.in" size_t nv=checkArray(z); // Call robust version of Gilles Dumoulin's port of Paul Bourke's // triangulation code. @@ -2065,12 +2066,12 @@ void gen_runarray69(stack *Stack) {Stack->push<Intarray2*>(t); return;} } -#line 1720 "runarray.in" +#line 1721 "runarray.in" // real norm(realarray *a); void gen_runarray70(stack *Stack) { realarray * a=vm::pop<realarray *>(Stack); -#line 1721 "runarray.in" +#line 1722 "runarray.in" size_t n=checkArray(a); real M=0.0; for(size_t i=0; i < n; ++i) { @@ -2080,12 +2081,12 @@ void gen_runarray70(stack *Stack) {Stack->push<real>(M); return;} } -#line 1731 "runarray.in" +#line 1732 "runarray.in" // real norm(realarray2 *a); void gen_runarray71(stack *Stack) { realarray2 * a=vm::pop<realarray2 *>(Stack); -#line 1732 "runarray.in" +#line 1733 "runarray.in" size_t n=checkArray(a); real M=0.0; for(size_t i=0; i < n; ++i) { @@ -2099,12 +2100,12 @@ void gen_runarray71(stack *Stack) {Stack->push<real>(M); return;} } -#line 1746 "runarray.in" +#line 1747 "runarray.in" // real norm(triplearray2 *a); void gen_runarray72(stack *Stack) { triplearray2 * a=vm::pop<triplearray2 *>(Stack); -#line 1747 "runarray.in" +#line 1748 "runarray.in" size_t n=checkArray(a); real M=0.0; for(size_t i=0; i < n; ++i) { @@ -2118,12 +2119,12 @@ void gen_runarray72(stack *Stack) {Stack->push<real>(sqrt(M)); return;} } -#line 1761 "runarray.in" +#line 1762 "runarray.in" // real change2(triplearray2 *a); void gen_runarray73(stack *Stack) { triplearray2 * a=vm::pop<triplearray2 *>(Stack); -#line 1762 "runarray.in" +#line 1763 "runarray.in" size_t n=checkArray(a); if(n == 0) {Stack->push<real>(0.0); return;} @@ -2144,13 +2145,13 @@ void gen_runarray73(stack *Stack) {Stack->push<real>(M); return;} } -#line 1783 "runarray.in" +#line 1784 "runarray.in" // triple minbezier(triplearray2 *P, triple b); void gen_runarray74(stack *Stack) { triple b=vm::pop<triple>(Stack); triplearray2 * P=vm::pop<triplearray2 *>(Stack); -#line 1784 "runarray.in" +#line 1785 "runarray.in" real *A=copyTripleArray2Components(P,true,4); b=triple(bound(A,::min,b.getx(),sqrtFuzz*norm(A,16)), bound(A+16,::min,b.gety(),sqrtFuzz*norm(A+16,16)), @@ -2159,13 +2160,13 @@ void gen_runarray74(stack *Stack) {Stack->push<triple>(b); return;} } -#line 1793 "runarray.in" +#line 1794 "runarray.in" // triple maxbezier(triplearray2 *P, triple b); void gen_runarray75(stack *Stack) { triple b=vm::pop<triple>(Stack); triplearray2 * P=vm::pop<triplearray2 *>(Stack); -#line 1794 "runarray.in" +#line 1795 "runarray.in" real *A=copyTripleArray2Components(P,true,4); b=triple(bound(A,::max,b.getx(),sqrtFuzz*norm(A,16)), bound(A+16,::max,b.gety(),sqrtFuzz*norm(A+16,16)), @@ -2174,13 +2175,13 @@ void gen_runarray75(stack *Stack) {Stack->push<triple>(b); return;} } -#line 1803 "runarray.in" +#line 1804 "runarray.in" // pair minratio(triplearray2 *P, pair b); void gen_runarray76(stack *Stack) { pair b=vm::pop<pair>(Stack); triplearray2 * P=vm::pop<triplearray2 *>(Stack); -#line 1804 "runarray.in" +#line 1805 "runarray.in" triple *A; copyArray2C(A,P,true,4); real fuzz=sqrtFuzz*norm(A,16); @@ -2190,13 +2191,13 @@ void gen_runarray76(stack *Stack) {Stack->push<pair>(b); return;} } -#line 1814 "runarray.in" +#line 1815 "runarray.in" // pair maxratio(triplearray2 *P, pair b); void gen_runarray77(stack *Stack) { pair b=vm::pop<pair>(Stack); triplearray2 * P=vm::pop<triplearray2 *>(Stack); -#line 1815 "runarray.in" +#line 1816 "runarray.in" triple *A; copyArray2C(A,P,true,4); real fuzz=sqrtFuzz*norm(A,16); @@ -2206,11 +2207,11 @@ void gen_runarray77(stack *Stack) {Stack->push<pair>(b); return;} } -#line 1825 "runarray.in" +#line 1826 "runarray.in" // realarray* _projection(); void gen_runarray78(stack *Stack) { -#line 1826 "runarray.in" +#line 1827 "runarray.in" #ifdef HAVE_GL array *a=new array(14); gl::projection P=gl::camera(); @@ -2271,139 +2272,139 @@ void gen_runarray_venv(venv &ve) REGISTER_BLTIN(run::arrayArrayRead,"arrayArrayRead"); #line 566 "runarray.in" REGISTER_BLTIN(run::arrayWrite,"arrayWrite"); -#line 582 "runarray.in" +#line 583 "runarray.in" REGISTER_BLTIN(run::arraySliceWrite,"arraySliceWrite"); -#line 590 "runarray.in" +#line 591 "runarray.in" REGISTER_BLTIN(run::arraySliceWriteToEnd,"arraySliceWriteToEnd"); -#line 598 "runarray.in" +#line 599 "runarray.in" REGISTER_BLTIN(run::arrayLength,"arrayLength"); -#line 604 "runarray.in" +#line 605 "runarray.in" REGISTER_BLTIN(run::arrayKeys,"arrayKeys"); -#line 619 "runarray.in" +#line 620 "runarray.in" REGISTER_BLTIN(run::arrayCyclicFlag,"arrayCyclicFlag"); -#line 626 "runarray.in" +#line 627 "runarray.in" REGISTER_BLTIN(run::arraySetCyclicFlag,"arraySetCyclicFlag"); -#line 633 "runarray.in" +#line 634 "runarray.in" REGISTER_BLTIN(run::arrayInitializedHelper,"arrayInitializedHelper"); -#line 644 "runarray.in" +#line 645 "runarray.in" REGISTER_BLTIN(run::arrayInitialized,"arrayInitialized"); -#line 650 "runarray.in" +#line 651 "runarray.in" REGISTER_BLTIN(run::arrayCyclicHelper,"arrayCyclicHelper"); -#line 657 "runarray.in" +#line 658 "runarray.in" REGISTER_BLTIN(run::arrayCyclic,"arrayCyclic"); -#line 663 "runarray.in" +#line 664 "runarray.in" REGISTER_BLTIN(run::arrayPushHelper,"arrayPushHelper"); -#line 671 "runarray.in" +#line 672 "runarray.in" REGISTER_BLTIN(run::arrayPush,"arrayPush"); -#line 677 "runarray.in" +#line 678 "runarray.in" REGISTER_BLTIN(run::arrayAppendHelper,"arrayAppendHelper"); -#line 686 "runarray.in" +#line 687 "runarray.in" REGISTER_BLTIN(run::arrayAppend,"arrayAppend"); -#line 692 "runarray.in" +#line 693 "runarray.in" REGISTER_BLTIN(run::arrayPopHelper,"arrayPopHelper"); -#line 701 "runarray.in" +#line 702 "runarray.in" REGISTER_BLTIN(run::arrayPop,"arrayPop"); -#line 707 "runarray.in" +#line 708 "runarray.in" REGISTER_BLTIN(run::arrayInsertHelper,"arrayInsertHelper"); -#line 718 "runarray.in" +#line 719 "runarray.in" REGISTER_BLTIN(run::arrayInsert,"arrayInsert"); -#line 724 "runarray.in" +#line 725 "runarray.in" REGISTER_BLTIN(run::arrayDelete,"arrayDelete"); -#line 730 "runarray.in" +#line 731 "runarray.in" REGISTER_BLTIN(run::arrayAlias,"arrayAlias"); -#line 735 "runarray.in" +#line 736 "runarray.in" REGISTER_BLTIN(run::arrayIntArray,"arrayIntArray"); -#line 753 "runarray.in" +#line 754 "runarray.in" addFunc(ve, run::gen_runarray33, IntArray(), SYM(complement), formal(IntArray(), SYM(a), false, false), formal(primInt(), SYM(n), false, false)); -#line 772 "runarray.in" +#line 773 "runarray.in" REGISTER_BLTIN(run::arraySequence,"arraySequence"); -#line 785 "runarray.in" +#line 786 "runarray.in" addFunc(ve, run::gen_runarray35, IntArray(), SYM(sequence), formal(primInt(), SYM(n), false, false)); -#line 796 "runarray.in" +#line 797 "runarray.in" REGISTER_BLTIN(run::arrayFunction,"arrayFunction"); -#line 809 "runarray.in" +#line 810 "runarray.in" REGISTER_BLTIN(run::arraySort,"arraySort"); -#line 818 "runarray.in" +#line 819 "runarray.in" REGISTER_BLTIN(run::arraySearch,"arraySearch"); -#line 837 "runarray.in" +#line 838 "runarray.in" addFunc(ve, run::gen_runarray39, primBoolean(), SYM(all), formal(booleanArray(), SYM(a), false, false)); -#line 846 "runarray.in" +#line 847 "runarray.in" addFunc(ve, run::gen_runarray40, booleanArray(), SYM_LOGNOT, formal(booleanArray(), SYM(a), false, false)); -#line 855 "runarray.in" +#line 856 "runarray.in" addFunc(ve, run::gen_runarray41, primInt(), SYM(sum), formal(booleanArray(), SYM(a), false, false)); -#line 864 "runarray.in" +#line 865 "runarray.in" REGISTER_BLTIN(run::arrayCopy,"arrayCopy"); -#line 869 "runarray.in" +#line 870 "runarray.in" REGISTER_BLTIN(run::arrayConcat,"arrayConcat"); -#line 897 "runarray.in" +#line 898 "runarray.in" REGISTER_BLTIN(run::array2Copy,"array2Copy"); -#line 902 "runarray.in" +#line 903 "runarray.in" REGISTER_BLTIN(run::array3Copy,"array3Copy"); -#line 907 "runarray.in" +#line 908 "runarray.in" REGISTER_BLTIN(run::array2Transpose,"array2Transpose"); -#line 931 "runarray.in" +#line 932 "runarray.in" REGISTER_BLTIN(run::array3Transpose,"array3Transpose"); -#line 1018 "runarray.in" +#line 1019 "runarray.in" addFunc(ve, run::gen_runarray48, primInt(), SYM(find), formal(booleanArray(), SYM(a), false, false), formal(primInt(), SYM(n), true, false)); -#line 1037 "runarray.in" +#line 1038 "runarray.in" REGISTER_BLTIN(run::arrayConditional,"arrayConditional"); -#line 1063 "runarray.in" +#line 1064 "runarray.in" addFunc(ve, run::gen_runarray50, realArray2(), SYM(identity), formal(primInt(), SYM(n), false, false)); -#line 1069 "runarray.in" +#line 1070 "runarray.in" addFunc(ve, run::gen_runarray51, realArray2(), SYM(inverse), formal(realArray2(), SYM(a), false, false)); -#line 1161 "runarray.in" +#line 1162 "runarray.in" addFunc(ve, run::gen_runarray52, realArray(), SYM(solve), formal(realArray2(), SYM(a), false, false), formal(realArray(), SYM(b), false, false), formal(primBoolean(), SYM(warn), true, false)); -#line 1214 "runarray.in" +#line 1215 "runarray.in" addFunc(ve, run::gen_runarray53, realArray2(), SYM(solve), formal(realArray2(), SYM(a), false, false), formal(realArray2(), SYM(b), false, false), formal(primBoolean(), SYM(warn), true, false)); -#line 1279 "runarray.in" +#line 1280 "runarray.in" addFunc(ve, run::gen_runarray54, primReal(), SYM(determinant), formal(realArray2(), SYM(a), false, false)); -#line 1296 "runarray.in" +#line 1297 "runarray.in" addFunc(ve, run::gen_runarray55, realArray(), SYM_TIMES, formal(realArray2(), SYM(a), false, false), formal(realArray(), SYM(b), false, false)); -#line 1315 "runarray.in" +#line 1316 "runarray.in" addFunc(ve, run::gen_runarray56, realArray(), SYM_TIMES, formal(realArray(), SYM(a), false, false), formal(realArray2(), SYM(b), false, false)); -#line 1344 "runarray.in" +#line 1345 "runarray.in" addFunc(ve, run::gen_runarray57, IntArray2(), SYM_TIMES, formal(IntArray2(), SYM(a), false, false), formal(IntArray2(), SYM(b), false, false)); -#line 1349 "runarray.in" +#line 1350 "runarray.in" addFunc(ve, run::gen_runarray58, realArray2(), SYM_TIMES, formal(realArray2(), SYM(a), false, false), formal(realArray2(), SYM(b), false, false)); -#line 1354 "runarray.in" +#line 1355 "runarray.in" addFunc(ve, run::gen_runarray59, pairArray2(), SYM_TIMES, formal(pairArray2(), SYM(a), false, false), formal(pairArray2(), SYM(b), false, false)); -#line 1359 "runarray.in" +#line 1360 "runarray.in" addFunc(ve, run::gen_runarray60, primTriple(), SYM_TIMES, formal(realArray2(), SYM(t), false, false), formal(primTriple(), SYM(v), false, false)); -#line 1364 "runarray.in" +#line 1365 "runarray.in" addFunc(ve, run::gen_runarray61, primPair(), SYM(project), formal(primTriple(), SYM(v), false, false), formal(realArray2(), SYM(t), false, false)); -#line 1389 "runarray.in" +#line 1390 "runarray.in" addFunc(ve, run::gen_runarray62, primReal(), SYM(dot), formal(realArray(), SYM(a), false, false), formal(realArray(), SYM(b), false, false)); -#line 1399 "runarray.in" +#line 1400 "runarray.in" addFunc(ve, run::gen_runarray63, primPair(), SYM(dot), formal(pairArray(), SYM(a), false, false), formal(pairArray(), SYM(b), false, false)); -#line 1409 "runarray.in" +#line 1410 "runarray.in" addFunc(ve, run::gen_runarray64, realArray(), SYM(tridiagonal), formal(realArray(), SYM(a), false, false), formal(realArray(), SYM(b), false, false), formal(realArray(), SYM(c), false, false), formal(realArray(), SYM(f), false, false)); -#line 1513 "runarray.in" +#line 1514 "runarray.in" addFunc(ve, run::gen_runarray65, primReal(), SYM(newton), formal(primInt(), SYM(iterations), true, false), formal(realRealFunction(), SYM(f), false, false), formal(realRealFunction(), SYM(fprime), false, false), formal(primReal(), SYM(x), false, false), formal(primBoolean(), SYM(verbose), true, false)); -#line 1560 "runarray.in" +#line 1561 "runarray.in" addFunc(ve, run::gen_runarray66, primReal(), SYM(newton), formal(primInt(), SYM(iterations), true, false), formal(realRealFunction(), SYM(f), false, false), formal(realRealFunction(), SYM(fprime), false, false), formal(primReal(), SYM(x1), false, false), formal(primReal(), SYM(x2), false, false), formal(primBoolean(), SYM(verbose), true, false)); -#line 1642 "runarray.in" +#line 1643 "runarray.in" addFunc(ve, run::gen_runarray67, primReal(), SYM(simpson), formal(realRealFunction(), SYM(f), false, false), formal(primReal(), SYM(a), false, false), formal(primReal(), SYM(b), false, false), formal(primReal(), SYM(acc), true, false), formal(primReal(), SYM(dxmax), true, false)); -#line 1654 "runarray.in" +#line 1655 "runarray.in" addFunc(ve, run::gen_runarray68, pairArray(), SYM(fft), formal(pairArray(), SYM(a), false, false), formal(primInt(), SYM(sign), true, false)); -#line 1685 "runarray.in" +#line 1686 "runarray.in" addFunc(ve, run::gen_runarray69, IntArray2(), SYM(triangulate), formal(pairArray(), SYM(z), false, false)); -#line 1720 "runarray.in" +#line 1721 "runarray.in" addFunc(ve, run::gen_runarray70, primReal(), SYM(norm), formal(realArray(), SYM(a), false, false)); -#line 1731 "runarray.in" +#line 1732 "runarray.in" addFunc(ve, run::gen_runarray71, primReal(), SYM(norm), formal(realArray2(), SYM(a), false, false)); -#line 1746 "runarray.in" +#line 1747 "runarray.in" addFunc(ve, run::gen_runarray72, primReal(), SYM(norm), formal(tripleArray2(), SYM(a), false, false)); -#line 1761 "runarray.in" +#line 1762 "runarray.in" addFunc(ve, run::gen_runarray73, primReal(), SYM(change2), formal(tripleArray2(), SYM(a), false, false)); -#line 1783 "runarray.in" +#line 1784 "runarray.in" addFunc(ve, run::gen_runarray74, primTriple(), SYM(minbezier), formal(tripleArray2(), SYM(p), false, false), formal(primTriple(), SYM(b), false, false)); -#line 1793 "runarray.in" +#line 1794 "runarray.in" addFunc(ve, run::gen_runarray75, primTriple(), SYM(maxbezier), formal(tripleArray2(), SYM(p), false, false), formal(primTriple(), SYM(b), false, false)); -#line 1803 "runarray.in" +#line 1804 "runarray.in" addFunc(ve, run::gen_runarray76, primPair(), SYM(minratio), formal(tripleArray2(), SYM(p), false, false), formal(primPair(), SYM(b), false, false)); -#line 1814 "runarray.in" +#line 1815 "runarray.in" addFunc(ve, run::gen_runarray77, primPair(), SYM(maxratio), formal(tripleArray2(), SYM(p), false, false), formal(primPair(), SYM(b), false, false)); -#line 1825 "runarray.in" +#line 1826 "runarray.in" addFunc(ve, run::gen_runarray78, realArray(), SYM(_projection)); } |