Entity:
Sequences 636 169
null  * 






Operation:
toColumn
Sequences
Sequence(Sequence(double))
s Sequence(double) 
 query static
true
result = s->collect( x | Sequence{ x } )









Operation:
subItems
Sequences
Sequence(double)
s Sequence(double) inds Sequence(int) 
 query static
true
result = inds->select( i | 1 <= i & i <= s.size )->collect( j | s[j] )




Operation:
sqFloor
Sequences
Sequence(int)
s Sequence(double) 
 query static
true
result = s->collect( x | x.floor )


Operation:
sqRound
Sequences
Sequence(int)
s Sequence(double) 
 query static
true
result = s->collect( x | x.round )


Operation:
sqAbs
Sequences
Sequence(double)
s Sequence(double) 
 query static
true
result = s->collect( x | x.abs )


Operation:
sqCeil
Sequences
Sequence(int)
s Sequence(double) 
 query static
true
result = s->collect( x | x.ceil )


Operation:
sqEq
Sequences
Sequence(boolean)
s Sequence(double) v double 
 query static
true
result = s->collect( e | e = v )


Operation:
sqLeq
Sequences
Sequence(boolean)
s Sequence(double) v double 
 query static
true
result = s->collect( e | e <= v )


Operation:
sqLess
Sequences
Sequence(boolean)
s Sequence(double) v double 
 query static
true
result = s->collect( e | e < v )


Operation:
sqAdd
Sequences
Sequence(double)
s Sequence(double) v double 
 query static
true
result = s->collect( e | e + v )




Operation:
sqAverage
Sequences
Sequence(double)
m Sequence(Sequence(double)) 
 query static
true
result = Integer.subrange(1,m[1].size)->collect( i | ( ( m->collect( row | row[i] )->sum() ) / m.size ) )




Operation:
ssAdd
Sequences
Sequence(double)
s1 Sequence(double) s2 Sequence(double) 
 query static
s1.size = s2.size
result = Integer.subrange(1,s1.size)->collect( i | s1[i] + s2[i] )


Operation:
ssSubtract
Sequences
Sequence(double)
s1 Sequence(double) s2 Sequence(double) 
 query static
s1.size = s2.size
result = Integer.subrange(1,s1.size)->collect( i | s1[i] - s2[i] )


Operation:
sqMult
Sequences
Sequence(double)
ss Sequence(double) v double 
 query static
true
result = ss->collect( e | e * v )


Operation:
ssMult
Sequences
Sequence(double)
s1 Sequence(double) s2 Sequence(double) 
 query static
s1.size = s2.size
result = Integer.subrange(1,s1.size)->collect( i | s1[i] * s2[i] )




Operation:
distance
Sequences
double
s1 Sequence(double) s2 Sequence(double) 
 query static
s1.size = s2.size
result = Integer.subrange(1,s1.size)->collect( i | (s1[i] - s2[i])->sqr() )->sum()->sqrt() 






Entity:
SimplexPoint 366 37
null  * 
coords Sequence(double) 3 false false false dim int 3 false false false fval double 3 false false false



Entity:
NFunction 48 142
null  * abstract 


Operation:
apply
NFunction
double
p SimplexPoint 
 query abstract
true
true





Entity:
Function 48 542
null  * abstract 



Operation:
apply
Function
double
p double 
 query abstract
true
true









Entity:
Simplex 259 149
null  * 
dim int 3 false false false


Operation:
sortPoints
Simplex
boolean


true
points = points@pre->sortedBy(fval) & result = true



Operation:
diameter
Simplex
double

query
true
result = Sequences.distance(points.first.coords, points.last.coords)



Operation:
initialise
Simplex
void
x SimplexPoint 

true
x : points & Integer.subrange(1,x.dim)->forAll( i | SimplexPoint->exists( p | p.coords = ( x.coords.subrange(1,i - 1) ^ Sequence{( x.coords->at(i) ) * 1.05} ^ x.coords.subrange(i + 1,x.dim) ) & p.dim = x.dim & p : points ) ) & points->forAll( p | p.fval = f.apply(p) )



Operation:
computeMeanReflection
Simplex
void


true
SimplexPoint->exists( m | m.coords = Sequences.sqAverage(points.front->collect(coords)) & m.dim = dim & m.fval = f.apply(m) & mean = m ) & SimplexPoint->exists( r | r.coords = Sequences.ssSubtract(Sequences.sqMult(mean.coords,2.0),points.last.coords) & r.dim = dim & r.fval = f.apply(r) & reflection = r )



Operation:
expand
Simplex
void


true
SimplexPoint->exists( s | s.coords = Sequences.ssAdd(mean.coords,Sequences.sqMult(Sequences.ssSubtract(mean.coords,points.last.coords),2.0)) & s.dim = dim & s.fval = f.apply(s) & ( ( s.fval < reflection.fval => points[( dim + 1 )] = s ) & ( reflection.fval <= s.fval => points[( dim + 1 )] = reflection ) ) )



Operation:
shrink
Simplex
void
x1 SimplexPoint 

true
Integer.subrange(2,dim + 1)->forAll( i | points[i].coords = Sequences.ssAdd(x1.coords,Sequences.sqMult(Sequences.ssSubtract(points[i].coords,x1.coords),0.5)) & points[i].fval = f.apply(points[i]) )


Operation:
contractInside
Simplex
void
c SimplexPoint 

true
( ( c.fval < reflection.fval => points[( dim + 1 )] = c ) & ( reflection.fval <= c.fval => self.shrink(points.first) ) )


Operation:
contractOutside
Simplex
void
cc SimplexPoint 

true
( ( cc.fval < points.last.fval => points[( dim + 1 )] = cc ) & ( points.last.fval <= cc.fval => self.shrink(points.first) ) )


Operation:
contract
Simplex
void


true
( reflection.fval < points.last.fval => SimplexPoint->exists( c | c.coords = Sequences.ssAdd(mean.coords,Sequences.sqMult(Sequences.ssSubtract(reflection.coords,mean.coords),0.5)) & c.dim = dim & c.fval = f.apply(c) & self.contractInside(c) ) ) & ( reflection.fval >= points.last.fval => SimplexPoint->exists( cc | cc.coords = Sequences.ssAdd(mean.coords,Sequences.sqMult(Sequences.ssSubtract(points.last.coords,mean.coords),0.5)) & cc.dim = dim & cc.fval = f.apply(cc) & self.contractOutside(cc) ) )


Operation:
reflectExpand
Simplex
void


true
( points.first.fval <= reflection.fval & reflection.fval < points[dim].fval => points[( dim + 1 )] = reflection ) & ( reflection.fval < points.first.fval => self.expand() ) & ( points[dim].fval <= reflection.fval => self.contract() )


Operation:
iterate
Simplex
SimplexPoint
tol double 
 query
true
result = points[1]




Entity:
NumericOptLib 290 522
null  * 


Operation:
simplex
NumericOptLib
SimplexPoint
f NFunction x Sequence(double) tol double 
 query static
tol > 0
SimplexPoint->exists( p | p.dim = x.size & p.coords = x & Simplex->exists( sx | sx.f = f & sx.dim = x.size & sx.initialise(p) & result = sx.iterate(tol) ) )




Operation:
secant
NumericOptLib
double
f Function rn double rminus double fminus double tol double 
 query static
true
fn = f.apply(rn) & ( fn.abs < tol => result = rn ) & ( fn.abs >= tol => result = NumericOptLib.secant(f,rn - fn * ( ( rn - rminus ) / ( fn - fminus ) ),rn,fn,tol) )





Operation:
bisection
NumericOptLib
double
f Function low double high double fl double fh double tol double
 query static
fl * fh < 0
mid = ( high + low ) / 2 & fx = f.apply(mid) & ( high - low < tol => result = mid ) & ( high - low >= tol & fl * fx < 0 => result = NumericOptLib.bisection(f,low,mid,fl,fx,tol) ) & ( high - low >= tol & fx * fh < 0 => result = NumericOptLib.bisection(f,mid,high,fx,fh,tol) )





Operation:
newton
NumericOptLib
double
f Function df Function x double tol double 
 query static
tol > 0
fx = f.apply(x) & dfx = df.apply(x) & ( fx.abs < tol => result = x ) & ( fx.abs >= tol => result = NumericOptLib.newton(f,df,x - fx / dfx,tol) )





Association:
Simplex SimplexPoint -1 289 150 358 51 0 points null 
ordered 


Association:
Simplex NFunction 0 257 155 189 149 1 f null 


Association:
Simplex SimplexPoint 0 443 147 557 106 1 mean null 


Association:
Simplex SimplexPoint 0 485 180 650 104 1 reflection null 








Activity:
Simplex iterate
 execute sortPoints() ; while diameter() > tol do execute ( computeMeanReflection() & reflectExpand() & sortPoints() & points[1]->display() & diameter()->display() )  ; return points[1] 








Entity:
Matrix 652 285
null  * 


Operation:
determinant2
Matrix
double
m Sequence(Sequence(double)) 
 query static
m.size = 2 & m[1]->size() = 2
a1 = m[1]->at(1) & a2 = m[1]->at(2) & b1 = m[2]->at(1) & b2 = m[2]->at(2) & result = a1 * b2 - a2 * b1


Operation:
detaux
Matrix
double
x1 double y1 double x2 double y2 double 
 query static
true
result = x1 * y1 - x2 * y2


Operation:
determinant3
Matrix
double
m Sequence(Sequence(double)) 
 query static
m.size = 3 & m[1]->size() = 3
result = ( m[1]->at(1) ) * Matrix.detaux(m[2]->at(2),m[3]->at(3),m[2]->at(3),m[3]->at(2)) - ( m[1]->at(2) ) * Matrix.detaux(m[2]->at(1),m[3]->at(3),m[3]->at(1),m[2]->at(3)) + ( m[1]->at(3) ) * Matrix.detaux(m[2]->at(1),m[3]->at(2),m[2]->at(2),m[3]->at(1))


Operation:
lineqn3solution1
Matrix
double
m Sequence(Sequence(double)) d double d1 double d2 double d3 double 
 query static
m.size = 3 & m[1]->size() = 3 & d /= 0
m1 = Sequence{Sequence{m[1]->at(2),m[1]->at(3),d1},Sequence{m[2]->at(2),m[2]->at(3),d2},Sequence{m[3]->at(2),m[3]->at(3),d3}} & result = -Matrix.determinant3(m1) / d


Operation:
lineqn3solution2
Matrix
double
m Sequence(Sequence(double)) d double d1 double d2 double d3 double 
 query static
m.size = 3 & m[1]->size() = 3 & d /= 0
m1 = Sequence{Sequence{m[1]->at(1),m[1]->at(3),d1},Sequence{m[2]->at(1),m[2]->at(3),d2},Sequence{m[3]->at(1),m[3]->at(3),d3}} & result = Matrix.determinant3(m1) / d


Operation:
lineqn3solution3
Matrix
double
m Sequence(Sequence(double)) d double d1 double d2 double d3 double 
 query static
m.size = 3 & m[1]->size() = 3 & d /= 0
m1 = Sequence{Sequence{m[1]->at(1),m[1]->at(2),d1},Sequence{m[2]->at(1),m[2]->at(2),d2},Sequence{m[3]->at(1),m[3]->at(2),d3}} & result = -Matrix.determinant3(m1) / d




Operation:
matrixMult
Matrix
Sequence(Sequence(double))
s Sequence(Sequence(double)) v double 
 query static
true
result = s->collect( sq | Sequences.sqMult(sq,v) )


Operation:
mmMult
Matrix
Sequence(Sequence(double))
m1 Sequence(Sequence(double)) m2 Sequence(Sequence(double)) 
 query static
m1.size = m2.size
result = Integer.subrange(1,m1.size)->collect( i | Sequences.ssMult(m1[i],m2[i]) )


Operation:
rowMult
Matrix
Sequence(double)
s Sequence(double) m Sequence(Sequence(double)) 
 query static
true
sze = Set{ s.size, m[1].size }->min() & result = Integer.subrange(1,sze)->collect( i | Integer.Sum(1,m.size,k,s[k] * ( m[k]->at(i) )) )


Operation:
matrixProd
Matrix
Sequence(Sequence(double))
m1 Sequence(Sequence(double)) m2 Sequence(Sequence(double)) 
 query static
true
result = m1->collect( row | Matrix.rowMult(row,m2) )










Operation:
toRow
Matrix
Sequence(double)
m Sequence(Sequence(double)) 
 query static
true
result = m->collect( r | r[1] )








Operation:
cofactorMatrix
Matrix
Sequence(Sequence(double))
m Sequence(Sequence(double)) i int j int
 query static
true
result = (m.subrange(1, i-1) ^ m.subrange(i+1, m.size))->collect( r | r.subrange(1,j-1) ^ r.subrange(j+1,r.size))







Operation:
cofactor
Matrix
double
m Sequence(Sequence(double)) i int j int
 query static
true
weight = 1 - 2*((i+j) mod 2) & result = weight * Matrix.determinant(Matrix.cofactorMatrix(m,i,j))






Operation:
determinant4
Matrix
double
m Sequence(Sequence(double)) 
 query static
m.size >= 3 & m[1]->size() >= 3
result = Integer.subrange(1, m[1].size)->collect( i | (m[1]->at(i)) * Matrix.cofactor(m, 1, i) )->sum()  






Operation:
determinant
Matrix
double
m Sequence(Sequence(double)) 
 query static
m.size = m[1]->size()
(m.size = 1 => result = (m[1]->at(1))) & (m.size = 2 => result = Matrix.determinant2(m)) & (m.size = 3 => result = Matrix.determinant3(m)) & (m.size > 3 => result = Matrix.determinant4(m))










Operation:
adjoint
Matrix
Sequence(Sequence(double))
m Sequence(Sequence(double)) 
 query static
true
result = Integer.subrange(1, m.size)->collect( i | Integer.subrange(1, m[i].size)->collect( j | Matrix.cofactor(m, j, i) ) ) 






Operation:
inverse
Matrix
Sequence(Sequence(double))
m Sequence(Sequence(double)) 
 query static
true
result = Matrix.matrixMult( Matrix.adjoint(m), 1.0/Matrix.determinant(m) )







Operation:
solveEquations
Matrix
Sequence(double)
m Sequence(Sequence(double)) y Sequence(double) 
 query static
true
result = Matrix.toRow( Matrix.matrixProd( Matrix.inverse(m), Sequences.toColumn(y) ) )