Entity:
Sequences 777 26
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:
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:
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:
ssEq
Sequences
Sequence(boolean)
s1 Sequence(double) s2 Sequence(double) 
 query static
true
result = Integer.subrange(1,s1.size)->collect( i | s1[i] = s2[i] )


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


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


Operation:
toStringDouble
Sequences
String
s Sequence(double) 
 query static
true
result = "Sequence{ " + s->collect( x | x + " " )->sum() + "}"


Operation:
toStringInt
Sequences
String
s Sequence(int) 
 query static
true
result = "Sequence{ " + s->collect( x | x + " " )->sum() + "}"


Operation:
toStringBoolean
Sequences
String
s Sequence(boolean) 
 query static
true
result = "Sequence{ " + s->collect( x | x + " " )->sum() + "}"


Entity:
Matrix 813 354
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:
max
Matrix
double
m Sequence(Sequence(double)) 
 query static
true
result = m->collect( s | s->max() )->max()


Operation:
min
Matrix
double
m Sequence(Sequence(double)) 
 query static
true
result = m->collect( s | s->min() )->min()


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


Operation:
mmAdd
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.ssAdd(m1[i],m2[i]) )


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:
mmEq
Matrix
Sequence(Sequence(boolean))
m1 Sequence(Sequence(double)) m2 Sequence(Sequence(double)) 
 query static
true
result = Integer.subrange(1,m1.size)->collect( i | Sequences.ssEq(m1[i],m2[i]) )


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


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


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


Operation:
subColumns
Matrix
Sequence(Sequence(double))
m Sequence(Sequence(double)) s Sequence(int) 
 query static
true
result = m->collect( r | Sequences.subItems(r,s) )


Operation:
subMatrix
Matrix
Sequence(Sequence(double))
m Sequence(Sequence(double)) rows Sequence(int) cols Sequence(int) 
 query static
true
result = Matrix.subColumns(Matrix.subRows(m,rows),cols)


Operation:
setMatrix
Matrix
Sequence(Sequence(double))
m Sequence(Sequence(double)) vals Sequence(double) 
 query static
true
result = Integer.subrange(1,m.size)->collect( i | vals.subrange(1 + ( i - 1 ) * m[1].size,i * m[1].size) )


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)))


Operation:
toStringDouble
Matrix
String
s Sequence(Sequence(double)) 
 query static
true
result = "Sequence{ " + s->collect( x | Sequences.toStringDouble(x) + " " )->sum() + "}"


Operation:
toStringInt
Matrix
String
s Sequence(Sequence(int)) 
 query static
true
result = "Sequence{ " + s->collect( x | Sequences.toStringInt(x) + " " )->sum() + "}"


Operation:
toStringBoolean
Matrix
String
s Sequence(Sequence(boolean)) 
 query static
true
result = "Sequence{ " + s->collect( x | Sequences.toStringBoolean(x) + " " )->sum() + "}"


Entity:
InterestRate 421 27
null  * 
maturity double 3 false false false rate double 3 false false false

Entity:
YieldCurve 151 128
null  * abstract 


Operation:
yield
YieldCurve
double
duration double 
 query abstract
true
true


Entity:
NelsonSiegalYC 55 371
YieldCurve  * 
beta1 double 3 false false false beta2 double 3 false false false beta3 double 3 false false false lambda1 double 3 false false false

Operation:
nelsonsiegal
NelsonSiegalYC
double
t double v1 double v2 double v3 double lambda double 
 query static
true
tscaled = t / lambda & exptscaled = -tscaled->exp() & expratio = ( 1 - exptscaled ) / tscaled & result = v1 + v2 * expratio + v3 * ( expratio - exptscaled )


Operation:
ns
NelsonSiegalYC
double
t double v1 double v2 double v3 double lambda double 
 query static
true
( t = 0 => result = v1 + v2 ) & ( t > 0 => result = NelsonSiegalYC.nelsonsiegal(t,v1,v2,v3,lambda) )


Operation:
yield
NelsonSiegalYC
double
duration double 
 query
true
result = NelsonSiegalYC.ns(duration,beta1,beta2,beta3,lambda1)


Operation:
nsrow
NelsonSiegalYC
Sequence(double)
r InterestRate lambda double 
 query static
true
tscaled1 = r.maturity / lambda & exptscaled1 = -tscaled1->exp() & expratio1 = ( 1 - exptscaled1 ) / tscaled1 & result = Sequence{1.0,expratio1,expratio1 - exptscaled1}


Operation:
nsmatrix
NelsonSiegalYC
Sequence(Sequence(double))
r1 InterestRate r2 InterestRate r3 InterestRate lambda double 
 query static
true
result = Sequence{NelsonSiegalYC.nsrow(r1,lambda),NelsonSiegalYC.nsrow(r2,lambda),NelsonSiegalYC.nsrow(r3,lambda)}


Entity:
NelsonSiegalSvenssonYC 368 179
YieldCurve  * 
beta1 double 3 false false false beta2 double 3 false false false beta3 double 3 false false false beta4 double 3 false false false lambda1 double 3 false false false lambda2 double 3 false false false

Operation:
nelsonsiegalsvensson
NelsonSiegalSvenssonYC
double
t double v1 double v2 double v3 double v4 double lambda1 double lambda2 double 
 query static
true
tscaled1 = t / lambda1 & tscaled2 = t / lambda2 & exptscaled1 = -tscaled1->exp() & exptscaled2 = -tscaled2->exp() & expratio1 = ( 1 - exptscaled1 ) / tscaled1 & expratio2 = ( 1 - exptscaled2 ) / tscaled2 & result = v1 + v2 * expratio1 + v3 * ( expratio1 - exptscaled1 ) + v4 * ( expratio2 - exptscaled2 )


Operation:
nss
NelsonSiegalSvenssonYC
double
t double v1 double v2 double v3 double v4 double lambda1 double lambda2 double 
 query static
true
( t = 0 => result = v1 + v2 ) & ( t > 0 => result = NelsonSiegalSvenssonYC.nelsonsiegalsvensson(t,v1,v2,v3,v4,lambda1,lambda2) )


Operation:
yield
NelsonSiegalSvenssonYC
double
duration double 
 query
true
result = NelsonSiegalSvenssonYC.nss(duration,beta1,beta2,beta3,beta4,lambda1,lambda2)


Operation:
nssrow
NelsonSiegalSvenssonYC
Sequence(double)
r InterestRate lambda1 double lambda2 double 
 query static
true
tscaled1 = r.maturity / lambda1 & exptscaled1 = -tscaled1->exp() & expratio1 = ( 1 - exptscaled1 ) / tscaled1 & tscaled2 = r.maturity / lambda2 & exptscaled2 = -tscaled2->exp() & expratio2 = ( 1 - exptscaled2 ) / tscaled2 & result = Sequence{1.0,expratio1,expratio1 - exptscaled1,expratio2 - exptscaled2}


Operation:
nssmatrix
NelsonSiegalSvenssonYC
Sequence(Sequence(double))
r1 InterestRate r2 InterestRate r3 InterestRate r4 InterestRate lambda1 double lambda2 double 
 query static
true
row1 = NelsonSiegalSvenssonYC.nssrow(r1,lambda1,lambda2) & row2 = NelsonSiegalSvenssonYC.nssrow(r2,lambda1,lambda2) & row3 = NelsonSiegalSvenssonYC.nssrow(r3,lambda1,lambda2) & row4 = NelsonSiegalSvenssonYC.nssrow(r4,lambda1,lambda2) & result = Sequence{row1,row2,row3,row4}


Association:
YieldCurve InterestRate 1 178 129 422 33 0 marketData null 
ordered 

Generalisation:
YieldCurve NelsonSiegalYC 143 374 157 165



Generalisation:
YieldCurve NelsonSiegalSvenssonYC 367 242 266 167







GeneralUseCase:
testns 



false


Constraint:
null
true
NelsonSiegalYC->exists( yc | yc.beta1 = 0.06 & yc.beta2 = -0.04 & yc.beta3 = 0.02 & yc.lambda1 = 3 )
null testns
false



Constraint:
i : Integer.subrange(1,10)
null
self.yield(i)->display()
NelsonSiegalYC testns
false