summaryrefslogtreecommitdiff
path: root/graphics/asymptote/runarray.cc
diff options
context:
space:
mode:
Diffstat (limited to 'graphics/asymptote/runarray.cc')
-rw-r--r--graphics/asymptote/runarray.cc240
1 files changed, 121 insertions, 119 deletions
diff --git a/graphics/asymptote/runarray.cc b/graphics/asymptote/runarray.cc
index 0621833758..05c7f0a1a7 100644
--- a/graphics/asymptote/runarray.cc
+++ b/graphics/asymptote/runarray.cc
@@ -1257,21 +1257,23 @@ void array2Transpose(stack *Stack)
#line 1041 "runarray.in"
size_t asize=checkArray(a);
array *c=new array(0);
+ size_t csize=0;
for(size_t i=0; i < asize; i++) {
size_t ip=i+1;
array *ai=read<array*>(a,i);
size_t aisize=checkArray(ai);
- size_t csize=checkArray(c);
- if(csize < aisize) {
+ if(c->size() < aisize) {
c->resize(aisize);
- for(size_t j=csize; j < aisize; j++) {
- (*c)[j]=new array(ip);
- }
+ for(size_t j=csize; j < aisize; j++)
+ (*c)[j]=new array(0);
+ csize=aisize;
}
for(size_t j=0; j < aisize; j++) {
- array *cj=read<array*>(c,j);
- if(checkArray(cj) < ip) cj->resize(ip);
- (*cj)[i]=(*ai)[j];
+ if(!(*ai)[j].empty()) {
+ array *cj=read<array*>(c,j);
+ if(checkArray(cj) < ip) cj->resize(ip);
+ (*cj)[i]=(*ai)[j];
+ }
}
}
{Stack->push<array*>(c); return;}
@@ -1281,12 +1283,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 1068 "runarray.in"
+#line 1070 "runarray.in"
void array3Transpose(stack *Stack)
{
array * perm=vm::pop<array *>(Stack);
array * a=vm::pop<array *>(Stack);
-#line 1069 "runarray.in"
+#line 1071 "runarray.in"
const size_t DIM=3;
if(checkArray(perm) != DIM) {
@@ -1370,13 +1372,13 @@ void array3Transpose(stack *Stack)
// Find the index of the nth true value in a boolean array or -1 if not found.
// If n is negative, search backwards.
-#line 1153 "runarray.in"
+#line 1155 "runarray.in"
// Int find(boolarray *a, Int n=1);
void gen_runarray44(stack *Stack)
{
Int n=vm::pop<Int>(Stack,1);
boolarray * a=vm::pop<boolarray *>(Stack);
-#line 1154 "runarray.in"
+#line 1156 "runarray.in"
size_t size=checkArray(a);
Int j=-1;
if(n > 0)
@@ -1393,12 +1395,12 @@ void gen_runarray44(stack *Stack)
}
// Find all indices of true values in a boolean array.
-#line 1171 "runarray.in"
+#line 1173 "runarray.in"
// Intarray* findall(boolarray *a);
void gen_runarray45(stack *Stack)
{
boolarray * a=vm::pop<boolarray *>(Stack);
-#line 1172 "runarray.in"
+#line 1174 "runarray.in"
size_t size=checkArray(a);
array *b=new array(0);
for(size_t i=0; i < size; i++) {
@@ -1411,13 +1413,13 @@ void gen_runarray45(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 1185 "runarray.in"
+#line 1187 "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 1186 "runarray.in"
+#line 1188 "runarray.in"
size_t size=checkArray(a);
array *r=new array(size);
if(b && c) {
@@ -1441,22 +1443,22 @@ void arrayConditional(stack *Stack)
}
// Return an n x n identity matrix.
-#line 1210 "runarray.in"
+#line 1212 "runarray.in"
// realarray2* identity(Int n);
void gen_runarray47(stack *Stack)
{
Int n=vm::pop<Int>(Stack);
-#line 1211 "runarray.in"
+#line 1213 "runarray.in"
{Stack->push<realarray2*>(Identity(n)); return;}
}
// Return the inverse of an n x n matrix a using Gauss-Jordan elimination.
-#line 1216 "runarray.in"
+#line 1218 "runarray.in"
// realarray2* inverse(realarray2 *a);
void gen_runarray48(stack *Stack)
{
realarray2 * a=vm::pop<realarray2 *>(Stack);
-#line 1217 "runarray.in"
+#line 1219 "runarray.in"
size_t n=checkArray(a);
double *A;
copyArray2C(A,a,true,0,NoGC);
@@ -1469,14 +1471,14 @@ void gen_runarray48(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 1230 "runarray.in"
+#line 1232 "runarray.in"
// realarray* solve(realarray2 *a, realarray *b, bool warn=true);
void gen_runarray49(stack *Stack)
{
bool warn=vm::pop<bool>(Stack,true);
realarray * b=vm::pop<realarray *>(Stack);
realarray2 * a=vm::pop<realarray2 *>(Stack);
-#line 1231 "runarray.in"
+#line 1233 "runarray.in"
size_t n=checkArray(a);
if(n == 0) {Stack->push<realarray*>(new array(0)); return;}
@@ -1528,14 +1530,14 @@ void gen_runarray49(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 1283 "runarray.in"
+#line 1285 "runarray.in"
// realarray2* solve(realarray2 *a, realarray2 *b, bool warn=true);
void gen_runarray50(stack *Stack)
{
bool warn=vm::pop<bool>(Stack,true);
realarray2 * b=vm::pop<realarray2 *>(Stack);
realarray2 * a=vm::pop<realarray2 *>(Stack);
-#line 1284 "runarray.in"
+#line 1286 "runarray.in"
size_t n=checkArray(a);
if(n == 0) {Stack->push<realarray2*>(new array(0)); return;}
@@ -1597,12 +1599,12 @@ void gen_runarray50(stack *Stack)
}
// Compute the determinant of an n x n matrix.
-#line 1346 "runarray.in"
+#line 1348 "runarray.in"
// real determinant(realarray2 *a);
void gen_runarray51(stack *Stack)
{
realarray2 * a=vm::pop<realarray2 *>(Stack);
-#line 1347 "runarray.in"
+#line 1349 "runarray.in"
real *A;
copyArray2C(A,a);
size_t n=checkArray(a);
@@ -1617,13 +1619,13 @@ void gen_runarray51(stack *Stack)
{Stack->push<real>(det); return;}
}
-#line 1362 "runarray.in"
+#line 1364 "runarray.in"
// realarray* *(realarray2 *a, realarray *b);
void gen_runarray52(stack *Stack)
{
realarray * b=vm::pop<realarray *>(Stack);
realarray2 * a=vm::pop<realarray2 *>(Stack);
-#line 1363 "runarray.in"
+#line 1365 "runarray.in"
size_t n=checkArray(a);
size_t m=checkArray(b);
array *c=new array(n);
@@ -1641,13 +1643,13 @@ void gen_runarray52(stack *Stack)
{Stack->push<realarray*>(c); return;}
}
-#line 1381 "runarray.in"
+#line 1383 "runarray.in"
// realarray* *(realarray *a, realarray2 *b);
void gen_runarray53(stack *Stack)
{
realarray2 * b=vm::pop<realarray2 *>(Stack);
realarray * a=vm::pop<realarray *>(Stack);
-#line 1382 "runarray.in"
+#line 1384 "runarray.in"
size_t n=checkArray(a);
if(n != checkArray(b)) error(incommensurate);
real *A;
@@ -1675,62 +1677,62 @@ void gen_runarray53(stack *Stack)
{Stack->push<realarray*>(c); return;}
}
-#line 1410 "runarray.in"
+#line 1412 "runarray.in"
// Intarray2* *(Intarray2 *a, Intarray2 *b);
void gen_runarray54(stack *Stack)
{
Intarray2 * b=vm::pop<Intarray2 *>(Stack);
Intarray2 * a=vm::pop<Intarray2 *>(Stack);
-#line 1411 "runarray.in"
+#line 1413 "runarray.in"
{Stack->push<Intarray2*>(mult<Int>(a,b)); return;}
}
-#line 1415 "runarray.in"
+#line 1417 "runarray.in"
// realarray2* *(realarray2 *a, realarray2 *b);
void gen_runarray55(stack *Stack)
{
realarray2 * b=vm::pop<realarray2 *>(Stack);
realarray2 * a=vm::pop<realarray2 *>(Stack);
-#line 1416 "runarray.in"
+#line 1418 "runarray.in"
{Stack->push<realarray2*>(mult<real>(a,b)); return;}
}
-#line 1420 "runarray.in"
+#line 1422 "runarray.in"
// pairarray2* *(pairarray2 *a, pairarray2 *b);
void gen_runarray56(stack *Stack)
{
pairarray2 * b=vm::pop<pairarray2 *>(Stack);
pairarray2 * a=vm::pop<pairarray2 *>(Stack);
-#line 1421 "runarray.in"
+#line 1423 "runarray.in"
{Stack->push<pairarray2*>(mult<pair>(a,b)); return;}
}
-#line 1425 "runarray.in"
+#line 1427 "runarray.in"
// triple *(realarray2 *t, triple v);
void gen_runarray57(stack *Stack)
{
triple v=vm::pop<triple>(Stack);
realarray2 * t=vm::pop<realarray2 *>(Stack);
-#line 1426 "runarray.in"
+#line 1428 "runarray.in"
{Stack->push<triple>(*t*v); return;}
}
-#line 1430 "runarray.in"
+#line 1432 "runarray.in"
// realarray2* AtA(realarray2 *a);
void gen_runarray58(stack *Stack)
{
realarray2 * a=vm::pop<realarray2 *>(Stack);
-#line 1431 "runarray.in"
+#line 1433 "runarray.in"
{Stack->push<realarray2*>(AtA<real>(a)); return;}
}
-#line 1435 "runarray.in"
+#line 1437 "runarray.in"
// pair project(triple v, realarray2 *t);
void gen_runarray59(stack *Stack)
{
realarray2 * t=vm::pop<realarray2 *>(Stack);
triple v=vm::pop<triple>(Stack);
-#line 1436 "runarray.in"
+#line 1438 "runarray.in"
size_t n=checkArray(t);
if(n != 4) error(incommensurate);
array *t0=read<array*>(t,0);
@@ -1755,13 +1757,13 @@ void gen_runarray59(stack *Stack)
}
// Compute the dot product of vectors a and b.
-#line 1461 "runarray.in"
+#line 1463 "runarray.in"
// real dot(realarray *a, realarray *b);
void gen_runarray60(stack *Stack)
{
realarray * b=vm::pop<realarray *>(Stack);
realarray * a=vm::pop<realarray *>(Stack);
-#line 1462 "runarray.in"
+#line 1464 "runarray.in"
size_t n=checkArrays(a,b);
real sum=0.0;
for(size_t i=0; i < n; ++i)
@@ -1770,13 +1772,13 @@ void gen_runarray60(stack *Stack)
}
// Compute the complex dot product of vectors a and b.
-#line 1471 "runarray.in"
+#line 1473 "runarray.in"
// pair dot(pairarray *a, pairarray *b);
void gen_runarray61(stack *Stack)
{
pairarray * b=vm::pop<pairarray *>(Stack);
pairarray * a=vm::pop<pairarray *>(Stack);
-#line 1472 "runarray.in"
+#line 1474 "runarray.in"
size_t n=checkArrays(a,b);
pair sum=zero;
for(size_t i=0; i < n; ++i)
@@ -1791,7 +1793,7 @@ void gen_runarray61(stack *Stack)
// [ a[2] b[2] c[2] ]
// [ ... ]
// [ c[n-1] a[n-1] b[n-1] ]
-#line 1487 "runarray.in"
+#line 1489 "runarray.in"
// realarray* tridiagonal(realarray *a, realarray *b, realarray *c, realarray *f);
void gen_runarray62(stack *Stack)
{
@@ -1799,7 +1801,7 @@ void gen_runarray62(stack *Stack)
realarray * c=vm::pop<realarray *>(Stack);
realarray * b=vm::pop<realarray *>(Stack);
realarray * a=vm::pop<realarray *>(Stack);
-#line 1488 "runarray.in"
+#line 1490 "runarray.in"
size_t n=checkArrays(a,b);
checkEqual(n,checkArray(c));
checkEqual(n,checkArray(f));
@@ -1896,7 +1898,7 @@ void gen_runarray62(stack *Stack)
}
// Root solve by Newton-Raphson
-#line 1585 "runarray.in"
+#line 1587 "runarray.in"
// real newton(Int iterations=100, callableReal *f, callableReal *fprime, real x, bool verbose=false);
void gen_runarray63(stack *Stack)
{
@@ -1905,7 +1907,7 @@ void gen_runarray63(stack *Stack)
callableReal * fprime=vm::pop<callableReal *>(Stack);
callableReal * f=vm::pop<callableReal *>(Stack);
Int iterations=vm::pop<Int>(Stack,100);
-#line 1587 "runarray.in"
+#line 1589 "runarray.in"
static const real fuzz=1000.0*DBL_EPSILON;
Int i=0;
size_t oldPrec=0;
@@ -1951,7 +1953,7 @@ void gen_runarray63(stack *Stack)
// Root solve by Newton-Raphson bisection
// cf. routine rtsafe (Press et al., Numerical Recipes, 1991).
-#line 1633 "runarray.in"
+#line 1635 "runarray.in"
// real newton(Int iterations=100, callableReal *f, callableReal *fprime, real x1, real x2, bool verbose=false);
void gen_runarray64(stack *Stack)
{
@@ -1961,7 +1963,7 @@ void gen_runarray64(stack *Stack)
callableReal * fprime=vm::pop<callableReal *>(Stack);
callableReal * f=vm::pop<callableReal *>(Stack);
Int iterations=vm::pop<Int>(Stack,100);
-#line 1635 "runarray.in"
+#line 1637 "runarray.in"
static const real fuzz=1000.0*DBL_EPSILON;
size_t oldPrec=0;
if(verbose)
@@ -2047,7 +2049,7 @@ void gen_runarray64(stack *Stack)
// In this implementation, the binary search is interleaved
// with a modified version of quadratic interpolation.
// This is a C++ port of the Asymptote routine written by Charles Staats III.
-#line 1721 "runarray.in"
+#line 1723 "runarray.in"
// real _findroot(callableReal *f, real a, real b, real tolerance, real fa, real fb);
void gen_runarray65(stack *Stack)
{
@@ -2057,7 +2059,7 @@ void gen_runarray65(stack *Stack)
real b=vm::pop<real>(Stack);
real a=vm::pop<real>(Stack);
callableReal * f=vm::pop<callableReal *>(Stack);
-#line 1723 "runarray.in"
+#line 1725 "runarray.in"
if(fa == 0.0) {Stack->push<real>(a); return;}
if(fb == 0.0) {Stack->push<real>(b); return;}
@@ -2149,7 +2151,7 @@ void gen_runarray65(stack *Stack)
{Stack->push<real>(a-(b-a)/(fb-fa)*fa); return;}
}
-#line 1815 "runarray.in"
+#line 1817 "runarray.in"
// real simpson(callableReal *f, real a, real b, real acc=DBL_EPSILON, real dxmax=0);
void gen_runarray66(stack *Stack)
{
@@ -2158,7 +2160,7 @@ void gen_runarray66(stack *Stack)
real b=vm::pop<real>(Stack);
real a=vm::pop<real>(Stack);
callableReal * f=vm::pop<callableReal *>(Stack);
-#line 1817 "runarray.in"
+#line 1819 "runarray.in"
real integral;
if(dxmax <= 0) dxmax=fabs(b-a);
callable *oldFunc=Func;
@@ -2171,13 +2173,13 @@ void gen_runarray66(stack *Stack)
}
// Compute the fast Fourier transform of a pair array
-#line 1830 "runarray.in"
+#line 1832 "runarray.in"
// pairarray* fft(pairarray *a, Int sign=1);
void gen_runarray67(stack *Stack)
{
Int sign=vm::pop<Int>(Stack,1);
pairarray * a=vm::pop<pairarray *>(Stack);
-#line 1831 "runarray.in"
+#line 1833 "runarray.in"
#ifdef HAVE_LIBFFTW3
unsigned n=(unsigned) checkArray(a);
array *c=new array(n);
@@ -2207,13 +2209,13 @@ void gen_runarray67(stack *Stack)
}
// Compute the fast Fourier transform of a 2D pair array
-#line 1861 "runarray.in"
+#line 1863 "runarray.in"
// pairarray2* fft(pairarray2 *a, Int sign=1);
void gen_runarray68(stack *Stack)
{
Int sign=vm::pop<Int>(Stack,1);
pairarray2 * a=vm::pop<pairarray2 *>(Stack);
-#line 1862 "runarray.in"
+#line 1864 "runarray.in"
#ifdef HAVE_LIBFFTW3
size_t n=checkArray(a);
size_t m=n == 0 ? 0 : checkArray(read<array*>(a,0));
@@ -2258,13 +2260,13 @@ void gen_runarray68(stack *Stack)
}
// Compute the fast Fourier transform of a 3D pair array
-#line 1907 "runarray.in"
+#line 1909 "runarray.in"
// pairarray3* fft(pairarray3 *a, Int sign=1);
void gen_runarray69(stack *Stack)
{
Int sign=vm::pop<Int>(Stack,1);
pairarray3 * a=vm::pop<pairarray3 *>(Stack);
-#line 1908 "runarray.in"
+#line 1910 "runarray.in"
#ifdef HAVE_LIBFFTW3
size_t n=checkArray(a);
array *a0=read<array*>(a,0);
@@ -2321,12 +2323,12 @@ void gen_runarray69(stack *Stack)
{Stack->push<pairarray3*>(c); return;}
}
-#line 1965 "runarray.in"
+#line 1967 "runarray.in"
// Intarray2* triangulate(pairarray *z);
void gen_runarray70(stack *Stack)
{
pairarray * z=vm::pop<pairarray *>(Stack);
-#line 1966 "runarray.in"
+#line 1968 "runarray.in"
size_t nv=checkArray(z);
// Call robust version of Gilles Dumoulin's port of Paul Bourke's
// triangulation code.
@@ -2360,12 +2362,12 @@ void gen_runarray70(stack *Stack)
{Stack->push<Intarray2*>(t); return;}
}
-#line 2000 "runarray.in"
+#line 2002 "runarray.in"
// real norm(realarray *a);
void gen_runarray71(stack *Stack)
{
realarray * a=vm::pop<realarray *>(Stack);
-#line 2001 "runarray.in"
+#line 2003 "runarray.in"
size_t n=checkArray(a);
real M=0.0;
for(size_t i=0; i < n; ++i) {
@@ -2375,12 +2377,12 @@ void gen_runarray71(stack *Stack)
{Stack->push<real>(M); return;}
}
-#line 2011 "runarray.in"
+#line 2013 "runarray.in"
// real norm(realarray2 *a);
void gen_runarray72(stack *Stack)
{
realarray2 * a=vm::pop<realarray2 *>(Stack);
-#line 2012 "runarray.in"
+#line 2014 "runarray.in"
size_t n=checkArray(a);
real M=0.0;
for(size_t i=0; i < n; ++i) {
@@ -2394,12 +2396,12 @@ void gen_runarray72(stack *Stack)
{Stack->push<real>(M); return;}
}
-#line 2026 "runarray.in"
+#line 2028 "runarray.in"
// real norm(triplearray2 *a);
void gen_runarray73(stack *Stack)
{
triplearray2 * a=vm::pop<triplearray2 *>(Stack);
-#line 2027 "runarray.in"
+#line 2029 "runarray.in"
size_t n=checkArray(a);
real M=0.0;
for(size_t i=0; i < n; ++i) {
@@ -2413,12 +2415,12 @@ void gen_runarray73(stack *Stack)
{Stack->push<real>(sqrt(M)); return;}
}
-#line 2041 "runarray.in"
+#line 2043 "runarray.in"
// real change2(triplearray2 *a);
void gen_runarray74(stack *Stack)
{
triplearray2 * a=vm::pop<triplearray2 *>(Stack);
-#line 2042 "runarray.in"
+#line 2044 "runarray.in"
size_t n=checkArray(a);
if(n == 0) {Stack->push<real>(0.0); return;}
@@ -2439,13 +2441,13 @@ void gen_runarray74(stack *Stack)
{Stack->push<real>(M); return;}
}
-#line 2063 "runarray.in"
+#line 2065 "runarray.in"
// triple minbezier(triplearray2 *P, triple b);
void gen_runarray75(stack *Stack)
{
triple b=vm::pop<triple>(Stack);
triplearray2 * P=vm::pop<triplearray2 *>(Stack);
-#line 2064 "runarray.in"
+#line 2066 "runarray.in"
size_t N;
real *A=copyTripleArray2Components(P,N);
bound_double *B=bounddouble(N);
@@ -2456,13 +2458,13 @@ void gen_runarray75(stack *Stack)
{Stack->push<triple>(b); return;}
}
-#line 2075 "runarray.in"
+#line 2077 "runarray.in"
// triple maxbezier(triplearray2 *P, triple b);
void gen_runarray76(stack *Stack)
{
triple b=vm::pop<triple>(Stack);
triplearray2 * P=vm::pop<triplearray2 *>(Stack);
-#line 2076 "runarray.in"
+#line 2078 "runarray.in"
size_t N;
real *A=copyTripleArray2Components(P,N);
bound_double *B=bounddouble(N);
@@ -2473,13 +2475,13 @@ void gen_runarray76(stack *Stack)
{Stack->push<triple>(b); return;}
}
-#line 2087 "runarray.in"
+#line 2089 "runarray.in"
// pair minratio(triplearray2 *P, pair b);
void gen_runarray77(stack *Stack)
{
pair b=vm::pop<pair>(Stack);
triplearray2 * P=vm::pop<triplearray2 *>(Stack);
-#line 2088 "runarray.in"
+#line 2090 "runarray.in"
size_t N;
triple *A=copyTripleArray2C(P,N);
real fuzz=Fuzz*norm(A,N);
@@ -2490,13 +2492,13 @@ void gen_runarray77(stack *Stack)
{Stack->push<pair>(b); return;}
}
-#line 2099 "runarray.in"
+#line 2101 "runarray.in"
// pair maxratio(triplearray2 *P, pair b);
void gen_runarray78(stack *Stack)
{
pair b=vm::pop<pair>(Stack);
triplearray2 * P=vm::pop<triplearray2 *>(Stack);
-#line 2100 "runarray.in"
+#line 2102 "runarray.in"
size_t N;
triple *A=copyTripleArray2C(P,N);
bound_triple *B=boundtriple(N);
@@ -2507,11 +2509,11 @@ void gen_runarray78(stack *Stack)
{Stack->push<pair>(b); return;}
}
-#line 2111 "runarray.in"
+#line 2113 "runarray.in"
// realarray* _projection();
void gen_runarray79(stack *Stack)
{
-#line 2112 "runarray.in"
+#line 2114 "runarray.in"
#ifdef HAVE_GL
array *a=new array(14);
gl::projection P=gl::camera();
@@ -2634,79 +2636,79 @@ void gen_runarray_venv(venv &ve)
REGISTER_BLTIN(run::arrayConcat,"arrayConcat");
#line 1040 "runarray.in"
REGISTER_BLTIN(run::array2Transpose,"array2Transpose");
-#line 1064 "runarray.in"
+#line 1066 "runarray.in"
REGISTER_BLTIN(run::array3Transpose,"array3Transpose");
-#line 1151 "runarray.in"
+#line 1153 "runarray.in"
addFunc(ve, run::gen_runarray44, primInt(), SYM(find), formal(booleanArray(), SYM(a), false, false), formal(primInt(), SYM(n), true, false));
-#line 1170 "runarray.in"
+#line 1172 "runarray.in"
addFunc(ve, run::gen_runarray45, IntArray(), SYM(findall), formal(booleanArray(), SYM(a), false, false));
-#line 1183 "runarray.in"
+#line 1185 "runarray.in"
REGISTER_BLTIN(run::arrayConditional,"arrayConditional");
-#line 1209 "runarray.in"
+#line 1211 "runarray.in"
addFunc(ve, run::gen_runarray47, realArray2(), SYM(identity), formal(primInt(), SYM(n), false, false));
-#line 1215 "runarray.in"
+#line 1217 "runarray.in"
addFunc(ve, run::gen_runarray48, realArray2(), SYM(inverse), formal(realArray2(), SYM(a), false, false));
-#line 1227 "runarray.in"
+#line 1229 "runarray.in"
addFunc(ve, run::gen_runarray49, realArray(), SYM(solve), formal(realArray2(), SYM(a), false, false), formal(realArray(), SYM(b), false, false), formal(primBoolean(), SYM(warn), true, false));
-#line 1280 "runarray.in"
+#line 1282 "runarray.in"
addFunc(ve, run::gen_runarray50, realArray2(), SYM(solve), formal(realArray2(), SYM(a), false, false), formal(realArray2(), SYM(b), false, false), formal(primBoolean(), SYM(warn), true, false));
-#line 1345 "runarray.in"
+#line 1347 "runarray.in"
addFunc(ve, run::gen_runarray51, primReal(), SYM(determinant), formal(realArray2(), SYM(a), false, false));
-#line 1362 "runarray.in"
+#line 1364 "runarray.in"
addFunc(ve, run::gen_runarray52, realArray(), SYM_TIMES, formal(realArray2(), SYM(a), false, false), formal(realArray(), SYM(b), false, false));
-#line 1381 "runarray.in"
+#line 1383 "runarray.in"
addFunc(ve, run::gen_runarray53, realArray(), SYM_TIMES, formal(realArray(), SYM(a), false, false), formal(realArray2(), SYM(b), false, false));
-#line 1410 "runarray.in"
+#line 1412 "runarray.in"
addFunc(ve, run::gen_runarray54, IntArray2(), SYM_TIMES, formal(IntArray2(), SYM(a), false, false), formal(IntArray2(), SYM(b), false, false));
-#line 1415 "runarray.in"
+#line 1417 "runarray.in"
addFunc(ve, run::gen_runarray55, realArray2(), SYM_TIMES, formal(realArray2(), SYM(a), false, false), formal(realArray2(), SYM(b), false, false));
-#line 1420 "runarray.in"
+#line 1422 "runarray.in"
addFunc(ve, run::gen_runarray56, pairArray2(), SYM_TIMES, formal(pairArray2(), SYM(a), false, false), formal(pairArray2(), SYM(b), false, false));
-#line 1425 "runarray.in"
+#line 1427 "runarray.in"
addFunc(ve, run::gen_runarray57, primTriple(), SYM_TIMES, formal(realArray2(), SYM(t), false, false), formal(primTriple(), SYM(v), false, false));
-#line 1430 "runarray.in"
+#line 1432 "runarray.in"
addFunc(ve, run::gen_runarray58, realArray2(), SYM(AtA), formal(realArray2(), SYM(a), false, false));
-#line 1435 "runarray.in"
+#line 1437 "runarray.in"
addFunc(ve, run::gen_runarray59, primPair(), SYM(project), formal(primTriple(), SYM(v), false, false), formal(realArray2(), SYM(t), false, false));
-#line 1460 "runarray.in"
+#line 1462 "runarray.in"
addFunc(ve, run::gen_runarray60, primReal(), SYM(dot), formal(realArray(), SYM(a), false, false), formal(realArray(), SYM(b), false, false));
-#line 1470 "runarray.in"
+#line 1472 "runarray.in"
addFunc(ve, run::gen_runarray61, primPair(), SYM(dot), formal(pairArray(), SYM(a), false, false), formal(pairArray(), SYM(b), false, false));
-#line 1480 "runarray.in"
+#line 1482 "runarray.in"
addFunc(ve, run::gen_runarray62, 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 1584 "runarray.in"
+#line 1586 "runarray.in"
addFunc(ve, run::gen_runarray63, 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 1631 "runarray.in"
+#line 1633 "runarray.in"
addFunc(ve, run::gen_runarray64, 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 1713 "runarray.in"
+#line 1715 "runarray.in"
addFunc(ve, run::gen_runarray65, primReal(), SYM(_findroot), formal(realRealFunction(), SYM(f), false, false), formal(primReal(), SYM(a), false, false), formal(primReal(), SYM(b), false, false), formal(primReal(), SYM(tolerance), false, false), formal(primReal(), SYM(fa), false, false), formal(primReal(), SYM(fb), false, false));
-#line 1815 "runarray.in"
+#line 1817 "runarray.in"
addFunc(ve, run::gen_runarray66, 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 1829 "runarray.in"
+#line 1831 "runarray.in"
addFunc(ve, run::gen_runarray67, pairArray(), SYM(fft), formal(pairArray(), SYM(a), false, false), formal(primInt(), SYM(sign), true, false));
-#line 1860 "runarray.in"
+#line 1862 "runarray.in"
addFunc(ve, run::gen_runarray68, pairArray2(), SYM(fft), formal(pairArray2(), SYM(a), false, false), formal(primInt(), SYM(sign), true, false));
-#line 1906 "runarray.in"
+#line 1908 "runarray.in"
addFunc(ve, run::gen_runarray69, pairArray3(), SYM(fft), formal(pairArray3(), SYM(a), false, false), formal(primInt(), SYM(sign), true, false));
-#line 1965 "runarray.in"
+#line 1967 "runarray.in"
addFunc(ve, run::gen_runarray70, IntArray2(), SYM(triangulate), formal(pairArray(), SYM(z), false, false));
-#line 2000 "runarray.in"
+#line 2002 "runarray.in"
addFunc(ve, run::gen_runarray71, primReal(), SYM(norm), formal(realArray(), SYM(a), false, false));
-#line 2011 "runarray.in"
+#line 2013 "runarray.in"
addFunc(ve, run::gen_runarray72, primReal(), SYM(norm), formal(realArray2(), SYM(a), false, false));
-#line 2026 "runarray.in"
+#line 2028 "runarray.in"
addFunc(ve, run::gen_runarray73, primReal(), SYM(norm), formal(tripleArray2(), SYM(a), false, false));
-#line 2041 "runarray.in"
+#line 2043 "runarray.in"
addFunc(ve, run::gen_runarray74, primReal(), SYM(change2), formal(tripleArray2(), SYM(a), false, false));
-#line 2063 "runarray.in"
+#line 2065 "runarray.in"
addFunc(ve, run::gen_runarray75, primTriple(), SYM(minbezier), formal(tripleArray2(), SYM(p), false, false), formal(primTriple(), SYM(b), false, false));
-#line 2075 "runarray.in"
+#line 2077 "runarray.in"
addFunc(ve, run::gen_runarray76, primTriple(), SYM(maxbezier), formal(tripleArray2(), SYM(p), false, false), formal(primTriple(), SYM(b), false, false));
-#line 2087 "runarray.in"
+#line 2089 "runarray.in"
addFunc(ve, run::gen_runarray77, primPair(), SYM(minratio), formal(tripleArray2(), SYM(p), false, false), formal(primPair(), SYM(b), false, false));
-#line 2099 "runarray.in"
+#line 2101 "runarray.in"
addFunc(ve, run::gen_runarray78, primPair(), SYM(maxratio), formal(tripleArray2(), SYM(p), false, false), formal(primPair(), SYM(b), false, false));
-#line 2111 "runarray.in"
+#line 2113 "runarray.in"
addFunc(ve, run::gen_runarray79, realArray(), SYM(_projection));
}