stepan
/
dynare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More Dynare_pp reformatted and cleared from CWEB references 

git-svn-id: https://www.dynare.org/svn/dynare/dynare_v4@2183 ac1d8469-bf42-47a9-8791-bf33cf982152
time-shift
george 2008-10-20 16:19:58 +00:00
parent 5f5705de80
commit 0337bae230
14 changed files with 1972 additions and 1972 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
mex/sources/korderpert/Dyn_pp/tl/cc/normal_moments.h
View File

@ -9,10 +9,10 @@
class UNormalMoments:public TensorContainer<URSingleTensor> { class UNormalMoments:public TensorContainer<URSingleTensor> {
public: public:
UNormalMoments(int maxdim,const TwoDMatrix&v); UNormalMoments(int maxdim,const TwoDMatrix&v);
private: private:
void generateMoments(int maxdim,const TwoDMatrix&v); void generateMoments(int maxdim,const TwoDMatrix&v);
static bool selectEquiv(const Equivalence&e); static bool selectEquiv(const Equivalence&e);
}; };
/*:2*/ /*:2*/
@ -21,7 +21,7 @@ static bool selectEquiv(const Equivalence&e);
class FNormalMoments:public TensorContainer<FRSingleTensor> { class FNormalMoments:public TensorContainer<FRSingleTensor> {
public: public:
FNormalMoments(const UNormalMoments&moms); FNormalMoments(const UNormalMoments&moms);
}; };

96
mex/sources/korderpert/Dyn_pp/tl/cc/permutation.h
View File

@ -12,40 +12,40 @@
class Permutation{ class Permutation{
protected: protected:
IntSequence permap; IntSequence permap;
public: public:
Permutation(int len) Permutation(int len)
:permap(len){for(int i= 0;i<len;i++)permap[i]= i;} :permap(len){for(int i= 0;i<len;i++)permap[i]= i;}
Permutation(const Equivalence&e) Permutation(const Equivalence&e)
:permap(e.getN()){e.trace(permap);} :permap(e.getN()){e.trace(permap);}
Permutation(const Equivalence&e,const Permutation&per) Permutation(const Equivalence&e,const Permutation&per)
:permap(e.getN()){e.trace(permap,per);} :permap(e.getN()){e.trace(permap,per);}
Permutation(const IntSequence&s) Permutation(const IntSequence&s)
:permap(s.size()){computeSortingMap(s);}; :permap(s.size()){computeSortingMap(s);};
Permutation(const Permutation&p) Permutation(const Permutation&p)
:permap(p.permap){} :permap(p.permap){}
Permutation(const Permutation&p1,const Permutation&p2) Permutation(const Permutation&p1,const Permutation&p2)
:permap(p2.permap){p1.apply(permap);} :permap(p2.permap){p1.apply(permap);}
Permutation(const Permutation&p,int i) Permutation(const Permutation&p,int i)
:permap(p.size(),p.permap,i){} :permap(p.size(),p.permap,i){}
const Permutation&operator= (const Permutation&p) const Permutation&operator= (const Permutation&p)
{permap= p.permap;return*this;} {permap= p.permap;return*this;}
bool operator==(const Permutation&p) bool operator==(const Permutation&p)
{return permap==p.permap;} {return permap==p.permap;}
int size()const int size()const
{return permap.size();} {return permap.size();}
void print()const void print()const
{permap.print();} {permap.print();}
void apply(const IntSequence&src,IntSequence&tar)const; void apply(const IntSequence&src,IntSequence&tar)const;
void apply(IntSequence&tar)const; void apply(IntSequence&tar)const;
void inverse(); void inverse();
int tailIdentity()const; int tailIdentity()const;
const IntSequence&getMap()const const IntSequence&getMap()const
{return permap;} {return permap;}
IntSequence&getMap() IntSequence&getMap()
{return permap;} {return permap;}
protected: protected:
void computeSortingMap(const IntSequence&s); void computeSortingMap(const IntSequence&s);
}; };
@ -54,18 +54,18 @@ void computeSortingMap(const IntSequence&s);
/*3:*/ /*3:*/
class PermutationSet{ class PermutationSet{
int order; int order;
int size; int size;
const Permutation**const pers; const Permutation**const pers;
public: public:
PermutationSet(); PermutationSet();
PermutationSet(const PermutationSet&ps,int n); PermutationSet(const PermutationSet&ps,int n);
~PermutationSet(); ~PermutationSet();
int getNum()const int getNum()const
{return size;} {return size;}
const Permutation&get(int i)const const Permutation&get(int i)const
{return*(pers[i]);} {return*(pers[i]);}
vector<const Permutation*> getPreserving(const IntSequence&s)const; vector<const Permutation*> getPreserving(const IntSequence&s)const;
}; };
@ -74,12 +74,12 @@ vector<const Permutation*> getPreserving(const IntSequence&s)const;
/*4:*/ /*4:*/
class PermutationBundle{ class PermutationBundle{
vector<PermutationSet*> bundle; vector<PermutationSet*> bundle;
public: public:
PermutationBundle(int nmax); PermutationBundle(int nmax);
~PermutationBundle(); ~PermutationBundle();
const PermutationSet&get(int n)const; const PermutationSet&get(int n)const;
void generateUpTo(int nmax); void generateUpTo(int nmax);
}; };
/*:4*/ /*:4*/

266
mex/sources/korderpert/Dyn_pp/tl/cc/ps_tensor.h
View File

@ -15,8 +15,8 @@
class SortIntSequence:public IntSequence{ class SortIntSequence:public IntSequence{
public: public:
SortIntSequence(const IntSequence&s) SortIntSequence(const IntSequence&s)
:IntSequence(s){sort();} :IntSequence(s){sort();}
}; };
@ -26,31 +26,31 @@ SortIntSequence(const IntSequence&s)
class PerTensorDimens:public TensorDimens{ class PerTensorDimens:public TensorDimens{
protected: protected:
Permutation per; Permutation per;
public: public:
PerTensorDimens(const Symmetry&s,const IntSequence&nvars, PerTensorDimens(const Symmetry&s,const IntSequence&nvars,
const Equivalence&e) const Equivalence&e)
:TensorDimens(s,nvars),per(e) :TensorDimens(s,nvars),per(e)
{per.apply(nvmax);} {per.apply(nvmax);}
PerTensorDimens(const TensorDimens&td,const Equivalence&e) PerTensorDimens(const TensorDimens&td,const Equivalence&e)
:TensorDimens(td),per(e) :TensorDimens(td),per(e)
{per.apply(nvmax);} {per.apply(nvmax);}
PerTensorDimens(const TensorDimens&td,const Permutation&p) PerTensorDimens(const TensorDimens&td,const Permutation&p)
:TensorDimens(td),per(p) :TensorDimens(td),per(p)
{per.apply(nvmax);} {per.apply(nvmax);}
PerTensorDimens(const IntSequence&ss,const IntSequence&coor) PerTensorDimens(const IntSequence&ss,const IntSequence&coor)
:TensorDimens(ss,SortIntSequence(coor)),per(coor) :TensorDimens(ss,SortIntSequence(coor)),per(coor)
{per.apply(nvmax);} {per.apply(nvmax);}
PerTensorDimens(const PerTensorDimens&td) PerTensorDimens(const PerTensorDimens&td)
:TensorDimens(td),per(td.per){} :TensorDimens(td),per(td.per){}
const PerTensorDimens&operator= (const PerTensorDimens&td) const PerTensorDimens&operator= (const PerTensorDimens&td)
{TensorDimens::operator= (td);per= td.per;return*this;} {TensorDimens::operator= (td);per= td.per;return*this;}
bool operator==(const PerTensorDimens&td) bool operator==(const PerTensorDimens&td)
{return TensorDimens::operator==(td)&&per==td.per;} {return TensorDimens::operator==(td)&&per==td.per;}
int tailIdentity()const int tailIdentity()const
{return per.tailIdentity();} {return per.tailIdentity();}
const Permutation&getPer()const const Permutation&getPer()const
{return per;} {return per;}
}; };
/*:3*/ /*:3*/
@ -58,54 +58,54 @@ const Permutation&getPer()const
/*4:*/ /*4:*/
class UPSTensor:public UTensor{ class UPSTensor:public UTensor{
const PerTensorDimens tdims; const PerTensorDimens tdims;
public: public:
/*5:*/ /*5:*/
UPSTensor(const TensorDimens&td,const Equivalence&e, UPSTensor(const TensorDimens&td,const Equivalence&e,
const ConstTwoDMatrix&a,const KronProdAll&kp) const ConstTwoDMatrix&a,const KronProdAll&kp)
:UTensor(along_col,PerTensorDimens(td,e).getNVX(), :UTensor(along_col,PerTensorDimens(td,e).getNVX(),
a.nrows(),kp.ncols(),td.dimen()),tdims(td,e) a.nrows(),kp.ncols(),td.dimen()),tdims(td,e)
{kp.mult(a,*this);} {kp.mult(a,*this);}
UPSTensor(const TensorDimens&td,const Equivalence&e, UPSTensor(const TensorDimens&td,const Equivalence&e,
const ConstTwoDMatrix&a,const KronProdAllOptim&kp) const ConstTwoDMatrix&a,const KronProdAllOptim&kp)
:UTensor(along_col,PerTensorDimens(td,Permutation(e,kp.getPer())).getNVX(), :UTensor(along_col,PerTensorDimens(td,Permutation(e,kp.getPer())).getNVX(),
a.nrows(),kp.ncols(),td.dimen()),tdims(td,Permutation(e,kp.getPer())) a.nrows(),kp.ncols(),td.dimen()),tdims(td,Permutation(e,kp.getPer()))
{kp.mult(a,*this);} {kp.mult(a,*this);}
UPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p, UPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p,
const ConstTwoDMatrix&a,const KronProdAll&kp) const ConstTwoDMatrix&a,const KronProdAll&kp)
:UTensor(along_col,PerTensorDimens(td,Permutation(e,p)).getNVX(), :UTensor(along_col,PerTensorDimens(td,Permutation(e,p)).getNVX(),
a.nrows(),kp.ncols(),td.dimen()),tdims(td,Permutation(e,p)) a.nrows(),kp.ncols(),td.dimen()),tdims(td,Permutation(e,p))
{kp.mult(a,*this);} {kp.mult(a,*this);}
UPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p, UPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p,
const ConstTwoDMatrix&a,const KronProdAllOptim&kp) const ConstTwoDMatrix&a,const KronProdAllOptim&kp)
:UTensor(along_col,PerTensorDimens(td,Permutation(e,Permutation(p,kp.getPer()))).getNVX(), :UTensor(along_col,PerTensorDimens(td,Permutation(e,Permutation(p,kp.getPer()))).getNVX(),
a.nrows(),kp.ncols(),td.dimen()),tdims(td,Permutation(e,Permutation(p,kp.getPer()))) a.nrows(),kp.ncols(),td.dimen()),tdims(td,Permutation(e,Permutation(p,kp.getPer())))
{kp.mult(a,*this);} {kp.mult(a,*this);}
/*:5*/ /*:5*/
; ;
UPSTensor(const FSSparseTensor&t,const IntSequence&ss, UPSTensor(const FSSparseTensor&t,const IntSequence&ss,
const IntSequence&coor,const PerTensorDimens&ptd); const IntSequence&coor,const PerTensorDimens&ptd);
UPSTensor(const UPSTensor&ut) UPSTensor(const UPSTensor&ut)
:UTensor(ut),tdims(ut.tdims){} :UTensor(ut),tdims(ut.tdims){}
void increment(IntSequence&v)const; void increment(IntSequence&v)const;
void decrement(IntSequence&v)const; void decrement(IntSequence&v)const;
FTensor&fold()const; FTensor&fold()const;
int getOffset(const IntSequence&v)const; int getOffset(const IntSequence&v)const;
void addTo(FGSTensor&out)const; void addTo(FGSTensor&out)const;
void addTo(UGSTensor&out)const; void addTo(UGSTensor&out)const;
enum fill_method{first,second}; enum fill_method{first,second};
static fill_method decideFillMethod(const FSSparseTensor&t); static fill_method decideFillMethod(const FSSparseTensor&t);
private: private:
int tailIdentitySize()const; int tailIdentitySize()const;
void fillFromSparseOne(const FSSparseTensor&t,const IntSequence&ss, void fillFromSparseOne(const FSSparseTensor&t,const IntSequence&ss,
const IntSequence&coor); const IntSequence&coor);
void fillFromSparseTwo(const FSSparseTensor&t,const IntSequence&ss, void fillFromSparseTwo(const FSSparseTensor&t,const IntSequence&ss,
const IntSequence&coor); const IntSequence&coor);
}; };
/*:4*/ /*:4*/
@ -113,30 +113,30 @@ const IntSequence&coor);
/*6:*/ /*6:*/
class PerTensorDimens2:public PerTensorDimens{ class PerTensorDimens2:public PerTensorDimens{
InducedSymmetries syms; InducedSymmetries syms;
IntSequence ds; IntSequence ds;
public: public:
PerTensorDimens2(const TensorDimens&td,const Equivalence&e, PerTensorDimens2(const TensorDimens&td,const Equivalence&e,
const Permutation&p) const Permutation&p)
:PerTensorDimens(td,Permutation(e,p)), :PerTensorDimens(td,Permutation(e,p)),
syms(e,p,td.getSym()), syms(e,p,td.getSym()),
ds(syms.size()) ds(syms.size())
{setDimensionSizes();} {setDimensionSizes();}
PerTensorDimens2(const TensorDimens&td,const Equivalence&e) PerTensorDimens2(const TensorDimens&td,const Equivalence&e)
:PerTensorDimens(td,e), :PerTensorDimens(td,e),
syms(e,td.getSym()), syms(e,td.getSym()),
ds(syms.size()) ds(syms.size())
{setDimensionSizes();} {setDimensionSizes();}
int numSyms()const int numSyms()const
{return(int)syms.size();} {return(int)syms.size();}
const Symmetry&getSym(int i)const const Symmetry&getSym(int i)const
{return syms[i];} {return syms[i];}
int calcMaxOffset()const int calcMaxOffset()const
{return ds.mult();} {return ds.mult();}
int calcOffset(const IntSequence&coor)const; int calcOffset(const IntSequence&coor)const;
void print()const; void print()const;
protected: protected:
void setDimensionSizes(); void setDimensionSizes();
}; };
/*:6*/ /*:6*/
@ -146,46 +146,46 @@ void setDimensionSizes();
template<typename _Ttype> class StackProduct; template<typename _Ttype> class StackProduct;
class FPSTensor:public FTensor{ class FPSTensor:public FTensor{
const PerTensorDimens2 tdims; const PerTensorDimens2 tdims;
public: public:
/*8:*/ /*8:*/
FPSTensor(const TensorDimens&td,const Equivalence&e, FPSTensor(const TensorDimens&td,const Equivalence&e,
const ConstTwoDMatrix&a,const KronProdAll&kp) const ConstTwoDMatrix&a,const KronProdAll&kp)
:FTensor(along_col,PerTensorDimens(td,e).getNVX(), :FTensor(along_col,PerTensorDimens(td,e).getNVX(),
a.nrows(),kp.ncols(),td.dimen()),tdims(td,e) a.nrows(),kp.ncols(),td.dimen()),tdims(td,e)
{kp.mult(a,*this);} {kp.mult(a,*this);}
FPSTensor(const TensorDimens&td,const Equivalence&e, FPSTensor(const TensorDimens&td,const Equivalence&e,
const ConstTwoDMatrix&a,const KronProdAllOptim&kp) const ConstTwoDMatrix&a,const KronProdAllOptim&kp)
:FTensor(along_col,PerTensorDimens(td,Permutation(e,kp.getPer())).getNVX(), :FTensor(along_col,PerTensorDimens(td,Permutation(e,kp.getPer())).getNVX(),
a.nrows(),kp.ncols(),td.dimen()),tdims(td,e,kp.getPer()) a.nrows(),kp.ncols(),td.dimen()),tdims(td,e,kp.getPer())
{kp.mult(a,*this);} {kp.mult(a,*this);}
FPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p, FPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p,
const ConstTwoDMatrix&a,const KronProdAll&kp) const ConstTwoDMatrix&a,const KronProdAll&kp)
:FTensor(along_col,PerTensorDimens(td,Permutation(e,p)).getNVX(), :FTensor(along_col,PerTensorDimens(td,Permutation(e,p)).getNVX(),
a.nrows(),kp.ncols(),td.dimen()),tdims(td,e,p) a.nrows(),kp.ncols(),td.dimen()),tdims(td,e,p)
{kp.mult(a,*this);} {kp.mult(a,*this);}
FPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p, FPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p,
const ConstTwoDMatrix&a,const KronProdAllOptim&kp) const ConstTwoDMatrix&a,const KronProdAllOptim&kp)
:FTensor(along_col,PerTensorDimens(td,Permutation(e,Permutation(p,kp.getPer()))).getNVX(), :FTensor(along_col,PerTensorDimens(td,Permutation(e,Permutation(p,kp.getPer()))).getNVX(),
a.nrows(),kp.ncols(),td.dimen()),tdims(td,e,Permutation(p,kp.getPer())) a.nrows(),kp.ncols(),td.dimen()),tdims(td,e,Permutation(p,kp.getPer()))
{kp.mult(a,*this);} {kp.mult(a,*this);}
FPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p, FPSTensor(const TensorDimens&td,const Equivalence&e,const Permutation&p,
const GSSparseTensor&t,const KronProdAll&kp); const GSSparseTensor&t,const KronProdAll&kp);
FPSTensor(const FPSTensor&ft) FPSTensor(const FPSTensor&ft)
:FTensor(ft),tdims(ft.tdims){} :FTensor(ft),tdims(ft.tdims){}
/*:8*/ /*:8*/
; ;
void increment(IntSequence&v)const; void increment(IntSequence&v)const;
void decrement(IntSequence&v)const; void decrement(IntSequence&v)const;
UTensor&unfold()const; UTensor&unfold()const;
int getOffset(const IntSequence&v)const; int getOffset(const IntSequence&v)const;
void addTo(FGSTensor&out)const; void addTo(FGSTensor&out)const;
}; };
/*:7*/ /*:7*/

8
mex/sources/korderpert/Dyn_pp/tl/cc/pyramid_prod.h
View File

@ -16,10 +16,10 @@ using namespace std;
class USubTensor:public URTensor{ class USubTensor:public URTensor{
public: public:
USubTensor(const TensorDimens&bdims,const TensorDimens&hdims, USubTensor(const TensorDimens&bdims,const TensorDimens&hdims,
const FGSContainer&cont,const vector<IntSequence> &lst); const FGSContainer&cont,const vector<IntSequence> &lst);
void addKronColumn(int i,const vector<const FGSTensor*> &ts, void addKronColumn(int i,const vector<const FGSTensor*> &ts,
const IntSequence&pindex); const IntSequence&pindex);
}; };
/*:2*/ /*:2*/

42
mex/sources/korderpert/Dyn_pp/tl/cc/pyramid_prod2.h
View File

@ -15,20 +15,20 @@
class IrregTensor; class IrregTensor;
class IrregTensorHeader{ class IrregTensorHeader{
friend class IrregTensor; friend class IrregTensor;
int nv; int nv;
IntSequence unit_flag; IntSequence unit_flag;
Vector**const cols; Vector**const cols;
IntSequence end_seq; IntSequence end_seq;
public: public:
IrregTensorHeader(const StackProduct<FGSTensor> &sp,const IntSequence&c); IrregTensorHeader(const StackProduct<FGSTensor> &sp,const IntSequence&c);
~IrregTensorHeader(); ~IrregTensorHeader();
int dimen()const int dimen()const
{return unit_flag.size();} {return unit_flag.size();}
void increment(IntSequence&v)const; void increment(IntSequence&v)const;
int calcMaxOffset()const; int calcMaxOffset()const;
private: private:
IrregTensorHeader(const IrregTensorHeader&); IrregTensorHeader(const IrregTensorHeader&);
}; };
@ -37,16 +37,16 @@ IrregTensorHeader(const IrregTensorHeader&);
/*3:*/ /*3:*/
class IrregTensor:public Tensor{ class IrregTensor:public Tensor{
const IrregTensorHeader&header; const IrregTensorHeader&header;
public: public:
IrregTensor(const IrregTensorHeader&h); IrregTensor(const IrregTensorHeader&h);
void addTo(FRSingleTensor&out)const; void addTo(FRSingleTensor&out)const;
void increment(IntSequence&v)const void increment(IntSequence&v)const
{header.increment(v);} {header.increment(v);}
void decrement(IntSequence&v)const void decrement(IntSequence&v)const
{TL_RAISE("Not implemented error in IrregTensor::decrement");} {TL_RAISE("Not implemented error in IrregTensor::decrement");}
int getOffset(const IntSequence&v)const int getOffset(const IntSequence&v)const
{TL_RAISE("Not implemented error in IrregTensor::getOffset");return 0;} {TL_RAISE("Not implemented error in IrregTensor::getOffset");return 0;}
}; };
/*:3*/ /*:3*/

122
mex/sources/korderpert/Dyn_pp/tl/cc/rfs_tensor.h
View File

@ -11,30 +11,30 @@
class FRTensor; class FRTensor;
class URTensor:public UTensor{ class URTensor:public UTensor{
int nv; int nv;
public: public:
/*3:*/ /*3:*/
URTensor(int c,int nvar,int d) URTensor(int c,int nvar,int d)
:UTensor(along_row,IntSequence(d,nvar), :UTensor(along_row,IntSequence(d,nvar),
UFSTensor::calcMaxOffset(nvar,d),c,d),nv(nvar){} UFSTensor::calcMaxOffset(nvar,d),c,d),nv(nvar){}
URTensor(const URTensor&ut) URTensor(const URTensor&ut)
:UTensor(ut),nv(ut.nv){} :UTensor(ut),nv(ut.nv){}
URTensor(const FRTensor&ft); URTensor(const FRTensor&ft);
/*:3*/ /*:3*/
; ;
virtual~URTensor(){} virtual~URTensor(){}
void increment(IntSequence&v)const; void increment(IntSequence&v)const;
void decrement(IntSequence&v)const; void decrement(IntSequence&v)const;
FTensor&fold()const; FTensor&fold()const;
int getOffset(const IntSequence&v)const; int getOffset(const IntSequence&v)const;
int nvar()const int nvar()const
{return nv;} {return nv;}
Symmetry getSym()const Symmetry getSym()const
{return Symmetry(dimen());} {return Symmetry(dimen());}
}; };
/*:2*/ /*:2*/
@ -42,31 +42,31 @@ Symmetry getSym()const
/*4:*/ /*4:*/
class FRTensor:public FTensor{ class FRTensor:public FTensor{
int nv; int nv;
public: public:
/*5:*/ /*5:*/
FRTensor(int c,int nvar,int d) FRTensor(int c,int nvar,int d)
:FTensor(along_row,IntSequence(d,nvar), :FTensor(along_row,IntSequence(d,nvar),
FFSTensor::calcMaxOffset(nvar,d),c,d),nv(nvar){} FFSTensor::calcMaxOffset(nvar,d),c,d),nv(nvar){}
FRTensor(const FRTensor&ft) FRTensor(const FRTensor&ft)
:FTensor(ft),nv(ft.nv){} :FTensor(ft),nv(ft.nv){}
FRTensor(const URTensor&ut); FRTensor(const URTensor&ut);
/*:5*/ /*:5*/
; ;
virtual~FRTensor(){} virtual~FRTensor(){}
void increment(IntSequence&v)const; void increment(IntSequence&v)const;
void decrement(IntSequence&v)const; void decrement(IntSequence&v)const;
UTensor&unfold()const; UTensor&unfold()const;
int nvar()const int nvar()const
{return nv;} {return nv;}
int getOffset(const IntSequence&v)const int getOffset(const IntSequence&v)const
{return FTensor::getOffset(v,nv);} {return FTensor::getOffset(v,nv);}
Symmetry getSym()const Symmetry getSym()const
{return Symmetry(dimen());} {return Symmetry(dimen());}
}; };
/*:4*/ /*:4*/
@ -75,14 +75,14 @@ Symmetry getSym()const
class URSingleTensor:public URTensor{ class URSingleTensor:public URTensor{
public: public:
URSingleTensor(int nvar,int d) URSingleTensor(int nvar,int d)
:URTensor(1,nvar,d){} :URTensor(1,nvar,d){}
URSingleTensor(const vector<ConstVector> &cols); URSingleTensor(const vector<ConstVector> &cols);
URSingleTensor(const ConstVector&v,int d); URSingleTensor(const ConstVector&v,int d);
URSingleTensor(const URSingleTensor&ut) URSingleTensor(const URSingleTensor&ut)
:URTensor(ut){} :URTensor(ut){}
virtual~URSingleTensor(){} virtual~URSingleTensor(){}
FTensor&fold()const; FTensor&fold()const;
}; };
/*:6*/ /*:6*/
@ -91,12 +91,12 @@ FTensor&fold()const;
class FRSingleTensor:public FRTensor{ class FRSingleTensor:public FRTensor{
public: public:
FRSingleTensor(int nvar,int d) FRSingleTensor(int nvar,int d)
:FRTensor(1,nvar,d){} :FRTensor(1,nvar,d){}
FRSingleTensor(const URSingleTensor&ut); FRSingleTensor(const URSingleTensor&ut);
FRSingleTensor(const FRSingleTensor&ft) FRSingleTensor(const FRSingleTensor&ft)
:FRTensor(ft){} :FRTensor(ft){}
virtual~FRSingleTensor(){} virtual~FRSingleTensor(){}
}; };

130
mex/sources/korderpert/Dyn_pp/tl/cc/sparse_tensor.h
View File

@ -15,8 +15,8 @@ using namespace std;
/*2:*/ /*2:*/
struct ltseq{ struct ltseq{
bool operator()(const IntSequence&s1,const IntSequence&s2)const bool operator()(const IntSequence&s1,const IntSequence&s2)const
{return s1<s2;} {return s1<s2;}
}; };
/*:2*/ /*:2*/
@ -25,46 +25,46 @@ bool operator()(const IntSequence&s1,const IntSequence&s2)const
class SparseTensor{ class SparseTensor{
public: public:
typedef pair<int,double> Item; typedef pair<int,double> Item;
typedef multimap<IntSequence,Item,ltseq> Map; typedef multimap<IntSequence,Item,ltseq> Map;
typedef Map::const_iterator const_iterator; typedef Map::const_iterator const_iterator;
protected: protected:
typedef Map::iterator iterator; typedef Map::iterator iterator;
Map m; Map m;
const int dim; const int dim;
const int nr; const int nr;
const int nc; const int nc;
int first_nz_row; int first_nz_row;
int last_nz_row; int last_nz_row;
public: public:
SparseTensor(int d,int nnr,int nnc) SparseTensor(int d,int nnr,int nnc)
:dim(d),nr(nnr),nc(nnc),first_nz_row(nr),last_nz_row(-1){} :dim(d),nr(nnr),nc(nnc),first_nz_row(nr),last_nz_row(-1){}
SparseTensor(const SparseTensor&t) SparseTensor(const SparseTensor&t)
:m(t.m),dim(t.dim),nr(t.nr),nc(t.nc){} :m(t.m),dim(t.dim),nr(t.nr),nc(t.nc){}
virtual~SparseTensor(){} virtual~SparseTensor(){}
void insert(const IntSequence&s,int r,double c); void insert(const IntSequence&s,int r,double c);
const Map&getMap()const const Map&getMap()const
{return m;} {return m;}
int dimen()const int dimen()const
{return dim;} {return dim;}
int nrows()const int nrows()const
{return nr;} {return nr;}
int ncols()const int ncols()const
{return nc;} {return nc;}
double getFillFactor()const double getFillFactor()const
{return((double)m.size())/(nrows()*ncols());} {return((double)m.size())/(nrows()*ncols());}
double getFoldIndexFillFactor()const; double getFoldIndexFillFactor()const;
double getUnfoldIndexFillFactor()const; double getUnfoldIndexFillFactor()const;
int getNumNonZero()const int getNumNonZero()const
{return m.size();} {return m.size();}
int getFirstNonZeroRow()const int getFirstNonZeroRow()const
{return first_nz_row;} {return first_nz_row;}
int getLastNonZeroRow()const int getLastNonZeroRow()const
{return last_nz_row;} {return last_nz_row;}
virtual const Symmetry&getSym()const= 0; virtual const Symmetry&getSym()const= 0;
void print()const; void print()const;
bool isFinite()const; bool isFinite()const;
} }
/*:3*/ /*:3*/
@ -73,20 +73,20 @@ bool isFinite()const;
class FSSparseTensor:public SparseTensor{ class FSSparseTensor:public SparseTensor{
public: public:
typedef SparseTensor::const_iterator const_iterator; typedef SparseTensor::const_iterator const_iterator;
private: private:
const int nv; const int nv;
const Symmetry sym; const Symmetry sym;
public: public:
FSSparseTensor(int d,int nvar,int r); FSSparseTensor(int d,int nvar,int r);
FSSparseTensor(const FSSparseTensor&t); FSSparseTensor(const FSSparseTensor&t);
void insert(const IntSequence&s,int r,double c); void insert(const IntSequence&s,int r,double c);
void multColumnAndAdd(const Tensor&t,Vector&v)const; void multColumnAndAdd(const Tensor&t,Vector&v)const;
const Symmetry&getSym()const const Symmetry&getSym()const
{return sym;} {return sym;}
int nvar()const int nvar()const
{return nv;} {return nv;}
void print()const; void print()const;
}; };
@ -96,21 +96,21 @@ void print()const;
class GSSparseTensor:public SparseTensor{ class GSSparseTensor:public SparseTensor{
public: public:
typedef SparseTensor::const_iterator const_iterator; typedef SparseTensor::const_iterator const_iterator;
private: private:
const TensorDimens tdims; const TensorDimens tdims;
public: public:
GSSparseTensor(const FSSparseTensor&t,const IntSequence&ss, GSSparseTensor(const FSSparseTensor&t,const IntSequence&ss,
const IntSequence&coor,const TensorDimens&td); const IntSequence&coor,const TensorDimens&td);
GSSparseTensor(const GSSparseTensor&t) GSSparseTensor(const GSSparseTensor&t)
:SparseTensor(t),tdims(t.tdims){} :SparseTensor(t),tdims(t.tdims){}
void insert(const IntSequence&s,int r,double c); void insert(const IntSequence&s,int r,double c);
const Symmetry&getSym()const const Symmetry&getSym()const
{return tdims.getSym();} {return tdims.getSym();}
const TensorDimens&getDims()const const TensorDimens&getDims()const
{return tdims;} {return tdims;}
void print()const; void print()const;
}; };
/*:5*/ /*:5*/

934
mex/sources/korderpert/Dyn_pp/tl/cc/stack_container.h
View File

File diff suppressed because it is too large Load Diff

896
mex/sources/korderpert/Dyn_pp/tl/cc/sthread.h
View File

@ -12,464 +12,464 @@
#include <map> #include <map>
namespace sthread{ namespace sthread{
using namespace std; using namespace std;
class Empty{}; class Empty{};
/*2:*/ /*2:*/
template<bool condition,class Then,class Else> template<bool condition,class Then,class Else>
struct IF{ struct IF{
typedef Then RET; typedef Then RET;
}; };
template<class Then,class Else> template<class Then,class Else>
struct IF<false,Then,Else> { struct IF<false,Then,Else> {
typedef Else RET; typedef Else RET;
}; };
/*:2*/ /*:2*/
; ;
enum{posix,empty}; enum{posix,empty};
template<int> class thread_traits; template<int> class thread_traits;
template<int> class detach_thread; template<int> class detach_thread;
/*3:*/ /*3:*/
template<int thread_impl> template<int thread_impl>
class thread{ class thread{
typedef thread_traits<thread_impl> _Ttraits; typedef thread_traits<thread_impl> _Ttraits;
typedef typename _Ttraits::_Tthread _Tthread; typedef typename _Ttraits::_Tthread _Tthread;
_Tthread th; _Tthread th;
public:
virtual~thread(){}
_Tthread&getThreadIden()
{return th;}
const _Tthread&getThreadIden()const
{return th;}
virtual void operator()()= 0;
void run()
{_Ttraits::run(this);}
void detach_run()
{_Ttraits::detach_run(this);}
void exit()
{_Ttraits::exit();}
};
/*:3*/
;
/*4:*/
template<int thread_impl>
class thread_group{
typedef thread_traits<thread_impl> _Ttraits;
typedef thread<thread_impl> _Ctype;
list<_Ctype*> tlist;
typedef typename list<_Ctype*> ::iterator iterator;
public:
static int max_parallel_threads;
void insert(_Ctype*c)
{tlist.push_back(c);}
/*5:*/
~thread_group()
{
while(!tlist.empty()){
delete tlist.front();
tlist.pop_front();
}
}
/*:5*/
;
/*7:*/
void run()
{
int rem= tlist.size();
iterator pfirst= tlist.begin();
while(rem> 2*max_parallel_threads){
pfirst= run_portion(pfirst,max_parallel_threads);
rem-= max_parallel_threads;
}
if(rem> max_parallel_threads){
pfirst= run_portion(pfirst,rem/2);
rem-= rem/2;
}
run_portion(pfirst,rem);
}
/*:7*/
;
private:
/*6:*/
iterator run_portion(iterator start,int n)
{
int c= 0;
for(iterator i= start;c<n;++i,c++){
(*i)->run();
}
iterator ret;
c= 0;
for(ret= start;c<n;++ret,c++){
_Ttraits::join(*ret);
}
return ret;
}
/*:6*/
;
};
/*:4*/
;
/*8:*/
template<int thread_impl>
struct thread_traits{
typedef typename IF<thread_impl==posix,pthread_t,Empty> ::RET _Tthread;
typedef thread<thread_impl> _Ctype;
typedef detach_thread<thread_impl> _Dtype;
static void run(_Ctype*c);
static void detach_run(_Dtype*c);
static void exit();
static void join(_Ctype*c);
};
/*:8*/
;
/*9:*/
struct ltmmkey;
typedef pair<const void*,const char*> mmkey;
template<int thread_impl>
struct mutex_traits{
typedef typename IF<thread_impl==posix,pthread_mutex_t,Empty> ::RET _Tmutex;
typedef map<mmkey,pair<_Tmutex,int> ,ltmmkey> mutex_int_map;
static void init(_Tmutex&m);
static void lock(_Tmutex&m);
static void unlock(_Tmutex&m);
};
/*:9*/
;
/*10:*/
struct ltmmkey{
bool operator()(const mmkey&k1,const mmkey&k2)const
{return k1.first<k2.first||
(k1.first==k2.first&&strcmp(k1.second,k2.second)<0);}
};
template<int thread_impl>
class mutex_map
:public mutex_traits<thread_impl> ::mutex_int_map
{
typedef typename mutex_traits<thread_impl> ::_Tmutex _Tmutex;
typedef mutex_traits<thread_impl> _Mtraits;
typedef pair<_Tmutex,int> mmval;
typedef map<mmkey,mmval,ltmmkey> _Tparent;
typedef typename _Tparent::iterator iterator;
typedef typename _Tparent::value_type _mvtype;
_Tmutex m;
public:
mutex_map()
{_Mtraits::init(m);}
void insert(const void*c,const char*id,const _Tmutex&m)
{_Tparent::insert(_mvtype(mmkey(c,id),mmval(m,0)));}
bool check(const void*c,const char*id)const
{return _Tparent::find(mmkey(c,id))!=_Tparent::end();}
/*11:*/
mmval*get(const void*c,const char*id)
{
iterator it= _Tparent::find(mmkey(c,id));
if(it==_Tparent::end())
return NULL;
return&((*it).second);
}
/*:11*/
;
/*12:*/
void remove(const void*c,const char*id)
{
iterator it= _Tparent::find(mmkey(c,id));
if(it!=_Tparent::end())
erase(it);
}
/*:12*/
;
void lock_map()
{_Mtraits::lock(m);}
void unlock_map()
{_Mtraits::unlock(m);}
};
/*:10*/
;
/*13:*/
template<int thread_impl>
class synchro{
typedef typename mutex_traits<thread_impl> ::_Tmutex _Tmutex;
typedef mutex_traits<thread_impl> _Mtraits;
public:
typedef mutex_map<thread_impl> mutex_map_t;
private:
const void*caller;
const char*iden;
mutex_map_t&mutmap;
public:
synchro(const void*c,const char*id,mutex_map_t&mmap)
:caller(c),iden(id),mutmap(mmap)
{lock();}
~synchro()
{unlock();}
private:
/*14:*/
void lock(){
mutmap.lock_map();
if(!mutmap.check(caller,iden)){
_Tmutex mut;
_Mtraits::init(mut);
mutmap.insert(caller,iden,mut);
}
mutmap.get(caller,iden)->second++;
mutmap.unlock_map();
_Mtraits::lock(mutmap.get(caller,iden)->first);
}
/*:14*/
;
/*15:*/
void unlock(){
mutmap.lock_map();
if(mutmap.check(caller,iden)){
_Mtraits::unlock(mutmap.get(caller,iden)->first);
mutmap.get(caller,iden)->second--;
if(mutmap.get(caller,iden)->second==0)
mutmap.remove(caller,iden);
}
mutmap.unlock_map();
}
/*:15*/
;
};
/*:13*/
;
/*16:*/
template<int thread_impl>
struct cond_traits{
typedef typename IF<thread_impl==posix,pthread_cond_t,Empty> ::RET _Tcond;
typedef typename mutex_traits<thread_impl> ::_Tmutex _Tmutex;
static void init(_Tcond&cond);
static void broadcast(_Tcond&cond);
static void wait(_Tcond&cond,_Tmutex&mutex);
static void destroy(_Tcond&cond);
};
/*:16*/
;
/*17:*/
template<int thread_impl>
class condition_counter{
typedef typename mutex_traits<thread_impl> ::_Tmutex _Tmutex;
typedef typename cond_traits<thread_impl> ::_Tcond _Tcond;
int counter;
_Tmutex mut;
_Tcond cond;
bool changed;
public: public:
virtual~thread(){} /*18:*/
_Tthread&getThreadIden()
{return th;} condition_counter()
const _Tthread&getThreadIden()const :counter(0),changed(true)
{return th;} {
virtual void operator()()= 0; mutex_traits<thread_impl> ::init(mut);
void run() cond_traits<thread_impl> ::init(cond);
{_Ttraits::run(this);} }
void detach_run()
{_Ttraits::detach_run(this);} /*:18*/
void exit() ;
{_Ttraits::exit();} /*19:*/
};
~condition_counter()
/*:3*/ {
; cond_traits<thread_impl> ::destroy(cond);
/*4:*/ }
template<int thread_impl> /*:19*/
class thread_group{ ;
typedef thread_traits<thread_impl> _Ttraits; /*20:*/
typedef thread<thread_impl> _Ctype;
list<_Ctype*> tlist; void increase()
typedef typename list<_Ctype*> ::iterator iterator; {
mutex_traits<thread_impl> ::lock(mut);
counter++;
changed= true;
cond_traits<thread_impl> ::broadcast(cond);
mutex_traits<thread_impl> ::unlock(mut);
}
/*:20*/
;
/*21:*/
void decrease()
{
mutex_traits<thread_impl> ::lock(mut);
counter--;
changed= true;
cond_traits<thread_impl> ::broadcast(cond);
mutex_traits<thread_impl> ::unlock(mut);
}
/*:21*/
;
/*22:*/
int waitForChange()
{
mutex_traits<thread_impl> ::lock(mut);
if(!changed){
cond_traits<thread_impl> ::wait(cond,mut);
}
changed= false;
int res= counter;
mutex_traits<thread_impl> ::unlock(mut);
return res;
}
/*:22*/
;
};
/*:17*/
;
/*23:*/
template<int thread_impl>
class detach_thread:public thread<thread_impl> {
public: public:
static int max_parallel_threads; condition_counter<thread_impl> *counter;
void insert(_Ctype*c) detach_thread():counter(NULL){}
{tlist.push_back(c);} void installCounter(condition_counter<thread_impl> *c)
/*5:*/ {counter= c;}
void run()
~thread_group() {thread_traits<thread_impl> ::detach_run(this);}
{ };
while(!tlist.empty()){
delete tlist.front(); /*:23*/
tlist.pop_front(); ;
} /*24:*/
}
template<int thread_impl>
/*:5*/ class detach_thread_group{
; typedef thread_traits<thread_impl> _Ttraits;
/*7:*/ typedef cond_traits<thread_impl> _Ctraits;
typedef detach_thread<thread_impl> _Ctype;
void run() list<_Ctype*> tlist;
{ typedef typename list<_Ctype*> ::iterator iterator;
int rem= tlist.size(); condition_counter<thread_impl> counter;
iterator pfirst= tlist.begin(); public:
while(rem> 2*max_parallel_threads){ static int max_parallel_threads;
pfirst= run_portion(pfirst,max_parallel_threads); /*25:*/
rem-= max_parallel_threads;
} void insert(_Ctype*c)
if(rem> max_parallel_threads){ {
pfirst= run_portion(pfirst,rem/2); tlist.push_back(c);
rem-= rem/2; c->installCounter(&counter);
} }
run_portion(pfirst,rem);
} /*:25*/
;
/*26:*/
~detach_thread_group()
/*:7*/ {
; while(!tlist.empty()){
private: delete tlist.front();
/*6:*/ tlist.pop_front();
}
iterator run_portion(iterator start,int n) }
{
int c= 0; /*:26*/
for(iterator i= start;c<n;++i,c++){ ;
(*i)->run(); /*27:*/
}
iterator ret; void run()
c= 0; {
for(ret= start;c<n;++ret,c++){ int mpt= max_parallel_threads;
_Ttraits::join(*ret); iterator it= tlist.begin();
} while(it!=tlist.end()){
return ret; if(counter.waitForChange()<mpt){
} counter.increase();
(*it)->run();
++it;
/*:6*/ }
; }
}; while(counter.waitForChange()> 0){}
}
/*:4*/
;
/*8:*/ /*:27*/
;
template<int thread_impl> };
struct thread_traits{
typedef typename IF<thread_impl==posix,pthread_t,Empty> ::RET _Tthread; /*:24*/
typedef thread<thread_impl> _Ctype; ;
typedef detach_thread<thread_impl> _Dtype;
static void run(_Ctype*c);
static void detach_run(_Dtype*c);
static void exit();
static void join(_Ctype*c);
};
/*:8*/
;
/*9:*/
struct ltmmkey;
typedef pair<const void*,const char*> mmkey;
template<int thread_impl>
struct mutex_traits{
typedef typename IF<thread_impl==posix,pthread_mutex_t,Empty> ::RET _Tmutex;
typedef map<mmkey,pair<_Tmutex,int> ,ltmmkey> mutex_int_map;
static void init(_Tmutex&m);
static void lock(_Tmutex&m);
static void unlock(_Tmutex&m);
};
/*:9*/
;
/*10:*/
struct ltmmkey{
bool operator()(const mmkey&k1,const mmkey&k2)const
{return k1.first<k2.first||
(k1.first==k2.first&&strcmp(k1.second,k2.second)<0);}
};
template<int thread_impl>
class mutex_map
:public mutex_traits<thread_impl> ::mutex_int_map
{
typedef typename mutex_traits<thread_impl> ::_Tmutex _Tmutex;
typedef mutex_traits<thread_impl> _Mtraits;
typedef pair<_Tmutex,int> mmval;
typedef map<mmkey,mmval,ltmmkey> _Tparent;
typedef typename _Tparent::iterator iterator;
typedef typename _Tparent::value_type _mvtype;
_Tmutex m;
public:
mutex_map()
{_Mtraits::init(m);}
void insert(const void*c,const char*id,const _Tmutex&m)
{_Tparent::insert(_mvtype(mmkey(c,id),mmval(m,0)));}
bool check(const void*c,const char*id)const
{return _Tparent::find(mmkey(c,id))!=_Tparent::end();}
/*11:*/
mmval*get(const void*c,const char*id)
{
iterator it= _Tparent::find(mmkey(c,id));
if(it==_Tparent::end())
return NULL;
return&((*it).second);
}
/*:11*/
;
/*12:*/
void remove(const void*c,const char*id)
{
iterator it= _Tparent::find(mmkey(c,id));
if(it!=_Tparent::end())
erase(it);
}
/*:12*/
;
void lock_map()
{_Mtraits::lock(m);}
void unlock_map()
{_Mtraits::unlock(m);}
};
/*:10*/
;
/*13:*/
template<int thread_impl>
class synchro{
typedef typename mutex_traits<thread_impl> ::_Tmutex _Tmutex;
typedef mutex_traits<thread_impl> _Mtraits;
public:
typedef mutex_map<thread_impl> mutex_map_t;
private:
const void*caller;
const char*iden;
mutex_map_t&mutmap;
public:
synchro(const void*c,const char*id,mutex_map_t&mmap)
:caller(c),iden(id),mutmap(mmap)
{lock();}
~synchro()
{unlock();}
private:
/*14:*/
void lock(){
mutmap.lock_map();
if(!mutmap.check(caller,iden)){
_Tmutex mut;
_Mtraits::init(mut);
mutmap.insert(caller,iden,mut);
}
mutmap.get(caller,iden)->second++;
mutmap.unlock_map();
_Mtraits::lock(mutmap.get(caller,iden)->first);
}
/*:14*/
;
/*15:*/
void unlock(){
mutmap.lock_map();
if(mutmap.check(caller,iden)){
_Mtraits::unlock(mutmap.get(caller,iden)->first);
mutmap.get(caller,iden)->second--;
if(mutmap.get(caller,iden)->second==0)
mutmap.remove(caller,iden);
}
mutmap.unlock_map();
}
/*:15*/
;
};
/*:13*/
;
/*16:*/
template<int thread_impl>
struct cond_traits{
typedef typename IF<thread_impl==posix,pthread_cond_t,Empty> ::RET _Tcond;
typedef typename mutex_traits<thread_impl> ::_Tmutex _Tmutex;
static void init(_Tcond&cond);
static void broadcast(_Tcond&cond);
static void wait(_Tcond&cond,_Tmutex&mutex);
static void destroy(_Tcond&cond);
};
/*:16*/
;
/*17:*/
template<int thread_impl>
class condition_counter{
typedef typename mutex_traits<thread_impl> ::_Tmutex _Tmutex;
typedef typename cond_traits<thread_impl> ::_Tcond _Tcond;
int counter;
_Tmutex mut;
_Tcond cond;
bool changed;
public:
/*18:*/
condition_counter()
:counter(0),changed(true)
{
mutex_traits<thread_impl> ::init(mut);
cond_traits<thread_impl> ::init(cond);
}
/*:18*/
;
/*19:*/
~condition_counter()
{
cond_traits<thread_impl> ::destroy(cond);
}
/*:19*/
;
/*20:*/
void increase()
{
mutex_traits<thread_impl> ::lock(mut);
counter++;
changed= true;
cond_traits<thread_impl> ::broadcast(cond);
mutex_traits<thread_impl> ::unlock(mut);
}
/*:20*/
;
/*21:*/
void decrease()
{
mutex_traits<thread_impl> ::lock(mut);
counter--;
changed= true;
cond_traits<thread_impl> ::broadcast(cond);
mutex_traits<thread_impl> ::unlock(mut);
}
/*:21*/
;
/*22:*/
int waitForChange()
{
mutex_traits<thread_impl> ::lock(mut);
if(!changed){
cond_traits<thread_impl> ::wait(cond,mut);
}
changed= false;
int res= counter;
mutex_traits<thread_impl> ::unlock(mut);
return res;
}
/*:22*/
;
};
/*:17*/
;
/*23:*/
template<int thread_impl>
class detach_thread:public thread<thread_impl> {
public:
condition_counter<thread_impl> *counter;
detach_thread():counter(NULL){}
void installCounter(condition_counter<thread_impl> *c)
{counter= c;}
void run()
{thread_traits<thread_impl> ::detach_run(this);}
};
/*:23*/
;
/*24:*/
template<int thread_impl>
class detach_thread_group{
typedef thread_traits<thread_impl> _Ttraits;
typedef cond_traits<thread_impl> _Ctraits;
typedef detach_thread<thread_impl> _Ctype;
list<_Ctype*> tlist;
typedef typename list<_Ctype*> ::iterator iterator;
condition_counter<thread_impl> counter;
public:
static int max_parallel_threads;
/*25:*/
void insert(_Ctype*c)
{
tlist.push_back(c);
c->installCounter(&counter);
}
/*:25*/
;
/*26:*/
~detach_thread_group()
{
while(!tlist.empty()){
delete tlist.front();
tlist.pop_front();
}
}
/*:26*/
;
/*27:*/
void run()
{
int mpt= max_parallel_threads;
iterator it= tlist.begin();
while(it!=tlist.end()){
if(counter.waitForChange()<mpt){
counter.increase();
(*it)->run();
++it;
}
}
while(counter.waitForChange()> 0){}
}
/*:27*/
;
};
/*:24*/
;
#ifdef POSIX_THREADS #ifdef POSIX_THREADS
/*28:*/ /*28:*/
typedef detach_thread<posix> PosixThread; typedef detach_thread<posix> PosixThread;
typedef detach_thread_group<posix> PosixThreadGroup; typedef detach_thread_group<posix> PosixThreadGroup;
typedef synchro<posix> posix_synchro; typedef synchro<posix> posix_synchro;
class PosixSynchro:public posix_synchro{ class PosixSynchro:public posix_synchro{
public: public:
PosixSynchro(const void*c,const char*id); PosixSynchro(const void*c,const char*id);
}; };
#define THREAD sthread::PosixThread #define THREAD sthread::PosixThread
#define THREAD_GROUP sthread::PosixThreadGroup #define THREAD_GROUP sthread::PosixThreadGroup
#define SYNCHRO sthread::PosixSynchro #define SYNCHRO sthread::PosixSynchro
/*:28*/ /*:28*/
; ;
#else #else
/*29:*/ /*29:*/
typedef thread<empty> NoThread; typedef thread<empty> NoThread;
typedef thread_group<empty> NoThreadGroup; typedef thread_group<empty> NoThreadGroup;
typedef synchro<empty> no_synchro; typedef synchro<empty> no_synchro;
class NoSynchro{ class NoSynchro{
public: public:
NoSynchro(const void*c,const char*id){} NoSynchro(const void*c,const char*id){}
~NoSynchro(){} ~NoSynchro(){}
}; };
#define THREAD sthread::NoThread #define THREAD sthread::NoThread
#define THREAD_GROUP sthread::NoThreadGroup #define THREAD_GROUP sthread::NoThreadGroup
#define SYNCHRO sthread::NoSynchro #define SYNCHRO sthread::NoSynchro
/*:29*/ /*:29*/
; ;
#endif #endif
}; };

134
mex/sources/korderpert/Dyn_pp/tl/cc/symmetry.h
View File

@ -13,45 +13,45 @@
class Symmetry:public IntSequence{ class Symmetry:public IntSequence{
public: public:
/*3:*/ /*3:*/
Symmetry(int len,const char*dummy) Symmetry(int len,const char*dummy)
:IntSequence(len,0){} :IntSequence(len,0){}
Symmetry(int i1) Symmetry(int i1)
:IntSequence(1,i1){} :IntSequence(1,i1){}
Symmetry(int i1,int i2) Symmetry(int i1,int i2)
:IntSequence(2){operator[](0)= i1;operator[](1)= i2;} :IntSequence(2){operator[](0)= i1;operator[](1)= i2;}
Symmetry(int i1,int i2,int i3) Symmetry(int i1,int i2,int i3)
:IntSequence(3) :IntSequence(3)
{ {
operator[](0)= i1; operator[](0)= i1;
operator[](1)= i2; operator[](1)= i2;
operator[](2)= i3; operator[](2)= i3;
} }
Symmetry(int i1,int i2,int i3,int i4) Symmetry(int i1,int i2,int i3,int i4)
:IntSequence(4) :IntSequence(4)
{ {
operator[](0)= i1; operator[](0)= i1;
operator[](1)= i2; operator[](1)= i2;
operator[](2)= i3; operator[](2)= i3;
operator[](3)= i4; operator[](3)= i4;
} }
Symmetry(const Symmetry&s) Symmetry(const Symmetry&s)
:IntSequence(s){} :IntSequence(s){}
Symmetry(const Symmetry&s,const OrdSequence&cl) Symmetry(const Symmetry&s,const OrdSequence&cl)
:IntSequence(s,cl.getData()){} :IntSequence(s,cl.getData()){}
Symmetry(Symmetry&s,int len) Symmetry(Symmetry&s,int len)
:IntSequence(s,s.size()-len,s.size()){} :IntSequence(s,s.size()-len,s.size()){}
Symmetry(const IntSequence&s); Symmetry(const IntSequence&s);
/*:3*/ /*:3*/
; ;
int num()const int num()const
{return size();} {return size();}
int dimen()const int dimen()const
{return sum();} {return sum();}
int findClass(int i)const; int findClass(int i)const;
bool isFull()const; bool isFull()const;
}; };
/*:2*/ /*:2*/
@ -59,21 +59,21 @@ bool isFull()const;
/*4:*/ /*4:*/
class SymmetrySet{ class SymmetrySet{
Symmetry run; Symmetry run;
int dim; int dim;
public: public:
SymmetrySet(int d,int length) SymmetrySet(int d,int length)
:run(length,""),dim(d){} :run(length,""),dim(d){}
SymmetrySet(SymmetrySet&s,int d) SymmetrySet(SymmetrySet&s,int d)
:run(s.run,s.size()-1),dim(d){} :run(s.run,s.size()-1),dim(d){}
int dimen()const int dimen()const
{return dim;} {return dim;}
const Symmetry&sym()const const Symmetry&sym()const
{return run;} {return run;}
Symmetry&sym() Symmetry&sym()
{return run;} {return run;}
int size()const int size()const
{return run.size();} {return run.size();}
}; };
/*:4*/ /*:4*/
@ -81,18 +81,18 @@ int size()const
/*5:*/ /*5:*/
class symiterator{ class symiterator{
SymmetrySet&s; SymmetrySet&s;
symiterator*subit; symiterator*subit;
SymmetrySet*subs; SymmetrySet*subs;
bool end_flag; bool end_flag;
public: public:
symiterator(SymmetrySet&ss); symiterator(SymmetrySet&ss);
~symiterator(); ~symiterator();
symiterator&operator++(); symiterator&operator++();
bool isEnd()const bool isEnd()const
{return end_flag;} {return end_flag;}
const Symmetry&operator*()const const Symmetry&operator*()const
{return s.sym();} {return s.sym();}
}; };
@ -102,9 +102,9 @@ const Symmetry&operator*()const
class InducedSymmetries:public vector<Symmetry> { class InducedSymmetries:public vector<Symmetry> {
public: public:
InducedSymmetries(const Equivalence&e,const Symmetry&s); InducedSymmetries(const Equivalence&e,const Symmetry&s);
InducedSymmetries(const Equivalence&e,const Permutation&p,const Symmetry&s); InducedSymmetries(const Equivalence&e,const Permutation&p,const Symmetry&s);
void print()const; void print()const;
}; };

468
mex/sources/korderpert/Dyn_pp/tl/cc/t_container.h
View File

@ -17,8 +17,8 @@
/*2:*/ /*2:*/
struct ltsym{ struct ltsym{
bool operator()(const Symmetry&s1,const Symmetry&s2)const bool operator()(const Symmetry&s1,const Symmetry&s2)const
{return s1<s2;} {return s1<s2;}
}; };
/*:2*/ /*:2*/
@ -27,224 +27,224 @@ bool operator()(const Symmetry&s1,const Symmetry&s2)const
template<class _Ttype> class TensorContainer{ template<class _Ttype> class TensorContainer{
protected: protected:
typedef const _Ttype*_const_ptr; typedef const _Ttype*_const_ptr;
typedef _Ttype*_ptr; typedef _Ttype*_ptr;
typedef map<Symmetry,_ptr,ltsym> _Map; typedef map<Symmetry,_ptr,ltsym> _Map;
typedef typename _Map::value_type _mvtype; typedef typename _Map::value_type _mvtype;
public: public:
typedef typename _Map::iterator iterator; typedef typename _Map::iterator iterator;
typedef typename _Map::const_iterator const_iterator; typedef typename _Map::const_iterator const_iterator;
private: private:
int n; int n;
_Map m; _Map m;
protected: protected:
const EquivalenceBundle&ebundle; const EquivalenceBundle&ebundle;
public: public:
TensorContainer(int nn) TensorContainer(int nn)
:n(nn),ebundle(*(tls.ebundle)){} :n(nn),ebundle(*(tls.ebundle)){}
/*5:*/ /*5:*/
TensorContainer(const TensorContainer<_Ttype> &c) TensorContainer(const TensorContainer<_Ttype> &c)
:n(c.n),m(),ebundle(c.ebundle) :n(c.n),m(),ebundle(c.ebundle)
{ {
for(const_iterator it= c.m.begin();it!=c.m.end();++it){ for(const_iterator it= c.m.begin();it!=c.m.end();++it){
_Ttype*ten= new _Ttype(*((*it).second)); _Ttype*ten= new _Ttype(*((*it).second));
insert(ten); insert(ten);
} }
} }
/*:5*/ /*:5*/
; ;
/*6:*/ /*6:*/
TensorContainer(int first_row,int num,TensorContainer<_Ttype> &c) TensorContainer(int first_row,int num,TensorContainer<_Ttype> &c)
:n(c.n),ebundle(*(tls.ebundle)) :n(c.n),ebundle(*(tls.ebundle))
{ {
for(iterator it= c.m.begin();it!=c.m.end();++it){ for(iterator it= c.m.begin();it!=c.m.end();++it){
_Ttype*t= new _Ttype(first_row,num,*((*it).second)); _Ttype*t= new _Ttype(first_row,num,*((*it).second));
insert(t); insert(t);
} }
} }
/*:6*/ /*:6*/
; ;
/*7:*/ /*7:*/
_const_ptr get(const Symmetry&s)const _const_ptr get(const Symmetry&s)const
{ {
TL_RAISE_IF(s.num()!=num(), TL_RAISE_IF(s.num()!=num(),
"Incompatible symmetry lookup in TensorContainer::get"); "Incompatible symmetry lookup in TensorContainer::get");
const_iterator it= m.find(s); const_iterator it= m.find(s);
if(it==m.end()){ if(it==m.end()){
TL_RAISE("Symmetry not found in TensorContainer::get"); TL_RAISE("Symmetry not found in TensorContainer::get");
return NULL; return NULL;
}else{ }else{
return(*it).second; return(*it).second;
} }
} }
_ptr get(const Symmetry&s) _ptr get(const Symmetry&s)
{ {
TL_RAISE_IF(s.num()!=num(), TL_RAISE_IF(s.num()!=num(),
"Incompatible symmetry lookup in TensorContainer::get"); "Incompatible symmetry lookup in TensorContainer::get");
iterator it= m.find(s); iterator it= m.find(s);
if(it==m.end()){ if(it==m.end()){
TL_RAISE("Symmetry not found in TensorContainer::get"); TL_RAISE("Symmetry not found in TensorContainer::get");
return NULL; return NULL;
}else{ }else{
return(*it).second; return(*it).second;
} }
} }
/*:7*/ /*:7*/
; ;
/*8:*/ /*8:*/
bool check(const Symmetry&s)const bool check(const Symmetry&s)const
{ {
TL_RAISE_IF(s.num()!=num(), TL_RAISE_IF(s.num()!=num(),
"Incompatible symmetry lookup in TensorContainer::check"); "Incompatible symmetry lookup in TensorContainer::check");
const_iterator it= m.find(s); const_iterator it= m.find(s);
return it!=m.end(); return it!=m.end();
} }
/*:8*/ /*:8*/
; ;
/*9:*/ /*9:*/
void insert(_ptr t) void insert(_ptr t)
{ {
TL_RAISE_IF(t->getSym().num()!=num(), TL_RAISE_IF(t->getSym().num()!=num(),
"Incompatible symmetry insertion in TensorContainer::insert"); "Incompatible symmetry insertion in TensorContainer::insert");
TL_RAISE_IF(check(t->getSym()), TL_RAISE_IF(check(t->getSym()),
"Tensor already in container in TensorContainer::insert"); "Tensor already in container in TensorContainer::insert");
m.insert(_mvtype(t->getSym(),t)); m.insert(_mvtype(t->getSym(),t));
if(!t->isFinite()){ if(!t->isFinite()){
throw TLException(__FILE__,__LINE__,"NaN or Inf asserted in TensorContainer::insert"); throw TLException(__FILE__,__LINE__,"NaN or Inf asserted in TensorContainer::insert");
} }
} }
/*:9*/ /*:9*/
; ;
/*10:*/ /*10:*/
void remove(const Symmetry&s) void remove(const Symmetry&s)
{ {
iterator it= m.find(s); iterator it= m.find(s);
if(it!=m.end()){ if(it!=m.end()){
_ptr t= (*it).second; _ptr t= (*it).second;
m.erase(it); m.erase(it);
delete t; delete t;
} }
} }
/*:10*/ /*:10*/
; ;
/*11:*/ /*11:*/
void clear() void clear()
{ {
while(!m.empty()){ while(!m.empty()){
delete(*(m.begin())).second; delete(*(m.begin())).second;
m.erase(m.begin()); m.erase(m.begin());
} }
} }
/*:11*/ /*:11*/
; ;
/*15:*/ /*15:*/
vector<_const_ptr> vector<_const_ptr>
fetchTensors(const Symmetry&rsym,const Equivalence&e)const fetchTensors(const Symmetry&rsym,const Equivalence&e)const
{ {
vector<_const_ptr> res(e.numClasses()); vector<_const_ptr> res(e.numClasses());
int i= 0; int i= 0;
for(Equivalence::const_seqit it= e.begin(); for(Equivalence::const_seqit it= e.begin();
it!=e.end();++it,i++){ it!=e.end();++it,i++){
Symmetry s(rsym,*it); Symmetry s(rsym,*it);
res[i]= get(s); res[i]= get(s);
} }
return res; return res;
} }
/*:15*/ /*:15*/
; ;
/*12:*/ /*12:*/
int getMaxDim()const int getMaxDim()const
{ {
int res= -1; int res= -1;
for(const_iterator run= m.begin();run!=m.end();++run){ for(const_iterator run= m.begin();run!=m.end();++run){
int dim= (*run).first.dimen(); int dim= (*run).first.dimen();
if(dim> res) if(dim> res)
res= dim; res= dim;
} }
return res; return res;
} }
/*:12*/ /*:12*/
; ;
/*13:*/ /*13:*/
void print()const void print()const
{ {
printf("Tensor container: nvars=%d, tensors=%d\n",n,m.size()); printf("Tensor container: nvars=%d, tensors=%d\n",n,m.size());
for(const_iterator it= m.begin();it!=m.end();++it){ for(const_iterator it= m.begin();it!=m.end();++it){
printf("Symmetry: "); printf("Symmetry: ");
(*it).first.print(); (*it).first.print();
((*it).second)->print(); ((*it).second)->print();
} }
} }
/*:13*/ /*:13*/
; ;
/*14:*/ /*14:*/
void writeMat4(FILE*fd,const char*prefix)const void writeMat4(FILE*fd,const char*prefix)const
{ {
for(const_iterator it= begin();it!=end();++it){ for(const_iterator it= begin();it!=end();++it){
char lname[100]; char lname[100];
sprintf(lname,"%s_g",prefix); sprintf(lname,"%s_g",prefix);
const Symmetry&sym= (*it).first; const Symmetry&sym= (*it).first;
for(int i= 0;i<sym.num();i++){ for(int i= 0;i<sym.num();i++){
char tmp[10]; char tmp[10];
sprintf(tmp,"_%d",sym[i]); sprintf(tmp,"_%d",sym[i]);
strcat(lname,tmp); strcat(lname,tmp);
} }
ConstTwoDMatrix m(*((*it).second)); ConstTwoDMatrix m(*((*it).second));
m.writeMat4(fd,lname); m.writeMat4(fd,lname);
} }
} }
/*:14*/ /*:14*/
; ;
virtual~TensorContainer() virtual~TensorContainer()
{clear();} {clear();}
/*4:*/ /*4:*/
int num()const int num()const
{return n;} {return n;}
const EquivalenceBundle&getEqBundle()const const EquivalenceBundle&getEqBundle()const
{return ebundle;} {return ebundle;}
const_iterator begin()const const_iterator begin()const
{return m.begin();} {return m.begin();}
const_iterator end()const const_iterator end()const
{return m.end();} {return m.end();}
iterator begin() iterator begin()
{return m.begin();} {return m.begin();}
iterator end() iterator end()
{return m.end();} {return m.end();}
/*:4*/ /*:4*/
; ;
}; };
/*:3*/ /*:3*/
@ -254,12 +254,12 @@ iterator end()
class FGSContainer; class FGSContainer;
class UGSContainer:public TensorContainer<UGSTensor> { class UGSContainer:public TensorContainer<UGSTensor> {
public: public:
UGSContainer(int nn) UGSContainer(int nn)
:TensorContainer<UGSTensor> (nn){} :TensorContainer<UGSTensor> (nn){}
UGSContainer(const UGSContainer&uc) UGSContainer(const UGSContainer&uc)
:TensorContainer<UGSTensor> (uc){} :TensorContainer<UGSTensor> (uc){}
UGSContainer(const FGSContainer&c); UGSContainer(const FGSContainer&c);
void multAndAdd(const UGSTensor&t,UGSTensor&out)const; void multAndAdd(const UGSTensor&t,UGSTensor&out)const;
}; };
@ -268,20 +268,20 @@ void multAndAdd(const UGSTensor&t,UGSTensor&out)const;
/*17:*/ /*17:*/
class FGSContainer:public TensorContainer<FGSTensor> { class FGSContainer:public TensorContainer<FGSTensor> {
static const int num_one_time; static const int num_one_time;
public: public:
FGSContainer(int nn) FGSContainer(int nn)
:TensorContainer<FGSTensor> (nn){} :TensorContainer<FGSTensor> (nn){}
FGSContainer(const FGSContainer&fc) FGSContainer(const FGSContainer&fc)
:TensorContainer<FGSTensor> (fc){} :TensorContainer<FGSTensor> (fc){}
FGSContainer(const UGSContainer&c); FGSContainer(const UGSContainer&c);
void multAndAdd(const FGSTensor&t,FGSTensor&out)const; void multAndAdd(const FGSTensor&t,FGSTensor&out)const;
void multAndAdd(const UGSTensor&t,FGSTensor&out)const; void multAndAdd(const UGSTensor&t,FGSTensor&out)const;
private: private:
static Tensor::index static Tensor::index
getIndices(int num,vector<IntSequence> &out, getIndices(int num,vector<IntSequence> &out,
const Tensor::index&start, const Tensor::index&start,
const Tensor::index&end); const Tensor::index&end);
}; };

610
mex/sources/korderpert/Dyn_pp/tl/cc/t_polynomial.h
View File

@ -8,16 +8,16 @@
/*2:*/ /*2:*/
class PowerProvider{ class PowerProvider{
Vector origv; Vector origv;
URSingleTensor*ut; URSingleTensor*ut;
FRSingleTensor*ft; FRSingleTensor*ft;
int nv; int nv;
public: public:
PowerProvider(const ConstVector&v) PowerProvider(const ConstVector&v)
:origv(v),ut(NULL),ft(NULL),nv(v.length()){} :origv(v),ut(NULL),ft(NULL),nv(v.length()){}
~PowerProvider(); ~PowerProvider();
const URSingleTensor&getNext(const URSingleTensor*dummy); const URSingleTensor&getNext(const URSingleTensor*dummy);
const FRSingleTensor&getNext(const FRSingleTensor*dummy); const FRSingleTensor&getNext(const FRSingleTensor*dummy);
}; };
/*:2*/ /*:2*/
@ -26,226 +26,226 @@ const FRSingleTensor&getNext(const FRSingleTensor*dummy);
template<class _Ttype,class _TGStype,class _Stype> template<class _Ttype,class _TGStype,class _Stype>
class TensorPolynomial:public TensorContainer<_Ttype> { class TensorPolynomial:public TensorContainer<_Ttype> {
int nr; int nr;
int nv; int nv;
int maxdim; int maxdim;
typedef TensorContainer<_Ttype> _Tparent; typedef TensorContainer<_Ttype> _Tparent;
typedef typename _Tparent::_ptr _ptr; typedef typename _Tparent::_ptr _ptr;
public: public:
TensorPolynomial(int rows,int vars) TensorPolynomial(int rows,int vars)
:TensorContainer<_Ttype> (1), :TensorContainer<_Ttype> (1),
nr(rows),nv(vars),maxdim(0){} nr(rows),nv(vars),maxdim(0){}
TensorPolynomial(const TensorPolynomial<_Ttype,_TGStype,_Stype> &tp,int k) TensorPolynomial(const TensorPolynomial<_Ttype,_TGStype,_Stype> &tp,int k)
:TensorContainer<_Ttype> (tp), :TensorContainer<_Ttype> (tp),
nr(tp.nr),nv(tp.nv),maxdim(0){derivative(k);} nr(tp.nr),nv(tp.nv),maxdim(0){derivative(k);}
TensorPolynomial(int first_row,int num,TensorPolynomial<_Ttype,_TGStype,_Stype> &tp) TensorPolynomial(int first_row,int num,TensorPolynomial<_Ttype,_TGStype,_Stype> &tp)
:TensorContainer<_Ttype> (first_row,num,tp), :TensorContainer<_Ttype> (first_row,num,tp),
nr(num),nv(tp.nv),maxdim(tp.maxdim){} nr(num),nv(tp.nv),maxdim(tp.maxdim){}
/*4:*/ /*4:*/
TensorPolynomial(const TensorPolynomial<_Ttype,_TGStype,_Stype> &tp,const Vector&xval) TensorPolynomial(const TensorPolynomial<_Ttype,_TGStype,_Stype> &tp,const Vector&xval)
:TensorContainer<_Ttype> (1), :TensorContainer<_Ttype> (1),
nr(tp.nrows()),nv(tp.nvars()-xval.length()),maxdim(0) nr(tp.nrows()),nv(tp.nvars()-xval.length()),maxdim(0)
{ {
TL_RAISE_IF(nvars()<0, TL_RAISE_IF(nvars()<0,
"Length of xval too big in TensorPolynomial contract constructor"); "Length of xval too big in TensorPolynomial contract constructor");
IntSequence ss(2);ss[0]= xval.length();ss[1]= nvars(); IntSequence ss(2);ss[0]= xval.length();ss[1]= nvars();
IntSequence pp(2);pp[0]= 0;pp[1]= 1; IntSequence pp(2);pp[0]= 0;pp[1]= 1;
/*5:*/ /*5:*/
PowerProvider pwp(xval); PowerProvider pwp(xval);
for(int i= 1;i<=tp.maxdim;i++){ for(int i= 1;i<=tp.maxdim;i++){
const _Stype&xpow= pwp.getNext((const _Stype*)NULL); const _Stype&xpow= pwp.getNext((const _Stype*)NULL);
for(int j= 0;j<=tp.maxdim-i;j++){ for(int j= 0;j<=tp.maxdim-i;j++){
if(tp.check(Symmetry(i+j))){ if(tp.check(Symmetry(i+j))){
/*7:*/ /*7:*/
_Ttype*ten; _Ttype*ten;
if(_Tparent::check(Symmetry(j))){ if(_Tparent::check(Symmetry(j))){
ten= _Tparent::get(Symmetry(j)); ten= _Tparent::get(Symmetry(j));
}else{ }else{
ten= new _Ttype(nrows(),nvars(),j); ten= new _Ttype(nrows(),nvars(),j);
ten->zeros(); ten->zeros();
insert(ten); insert(ten);
} }
/*:7*/ /*:7*/
; ;
Symmetry sym(i,j); Symmetry sym(i,j);
IntSequence coor(sym,pp); IntSequence coor(sym,pp);
_TGStype slice(*(tp.get(Symmetry(i+j))),ss,coor,TensorDimens(sym,ss)); _TGStype slice(*(tp.get(Symmetry(i+j))),ss,coor,TensorDimens(sym,ss));
slice.mult(Tensor::noverk(i+j,j)); slice.mult(Tensor::noverk(i+j,j));
_TGStype tmp(*ten); _TGStype tmp(*ten);
slice.contractAndAdd(0,tmp,xpow); slice.contractAndAdd(0,tmp,xpow);
} }
} }
} }
/*:5*/ /*:5*/
; ;
/*6:*/ /*6:*/
for(int j= 0;j<=tp.maxdim;j++){ for(int j= 0;j<=tp.maxdim;j++){
if(tp.check(Symmetry(j))){ if(tp.check(Symmetry(j))){
/*7:*/ /*7:*/
_Ttype*ten; _Ttype*ten;
if(_Tparent::check(Symmetry(j))){ if(_Tparent::check(Symmetry(j))){
ten= _Tparent::get(Symmetry(j)); ten= _Tparent::get(Symmetry(j));
}else{ }else{
ten= new _Ttype(nrows(),nvars(),j); ten= new _Ttype(nrows(),nvars(),j);
ten->zeros(); ten->zeros();
insert(ten); insert(ten);
} }
/*:7*/ /*:7*/
; ;
Symmetry sym(0,j); Symmetry sym(0,j);
IntSequence coor(sym,pp); IntSequence coor(sym,pp);
_TGStype slice(*(tp.get(Symmetry(j))),ss,coor,TensorDimens(sym,ss)); _TGStype slice(*(tp.get(Symmetry(j))),ss,coor,TensorDimens(sym,ss));
ten->add(1.0,slice); ten->add(1.0,slice);
} }
} }
/*:6*/ /*:6*/
; ;
} }
/*:4*/ /*:4*/
; ;
TensorPolynomial(const TensorPolynomial&tp) TensorPolynomial(const TensorPolynomial&tp)
:TensorContainer<_Ttype> (tp),nr(tp.nr),nv(tp.nv),maxdim(tp.maxdim){} :TensorContainer<_Ttype> (tp),nr(tp.nr),nv(tp.nv),maxdim(tp.maxdim){}
int nrows()const int nrows()const
{return nr;} {return nr;}
int nvars()const int nvars()const
{return nv;} {return nv;}
/*8:*/ /*8:*/
void evalTrad(Vector&out,const ConstVector&v)const void evalTrad(Vector&out,const ConstVector&v)const
{ {
if(_Tparent::check(Symmetry(0))) if(_Tparent::check(Symmetry(0)))
out= _Tparent::get(Symmetry(0))->getData(); out= _Tparent::get(Symmetry(0))->getData();
else else
out.zeros(); out.zeros();
PowerProvider pp(v); PowerProvider pp(v);
for(int d= 1;d<=maxdim;d++){ for(int d= 1;d<=maxdim;d++){
const _Stype&p= pp.getNext((const _Stype*)NULL); const _Stype&p= pp.getNext((const _Stype*)NULL);
Symmetry cs(d); Symmetry cs(d);
if(_Tparent::check(cs)){ if(_Tparent::check(cs)){
const _Ttype*t= _Tparent::get(cs); const _Ttype*t= _Tparent::get(cs);
t->multaVec(out,p.getData()); t->multaVec(out,p.getData());
} }
} }
} }
/*:8*/ /*:8*/
; ;
/*9:*/ /*9:*/
void evalHorner(Vector&out,const ConstVector&v)const void evalHorner(Vector&out,const ConstVector&v)const
{ {
if(_Tparent::check(Symmetry(0))) if(_Tparent::check(Symmetry(0)))
out= _Tparent::get(Symmetry(0))->getData(); out= _Tparent::get(Symmetry(0))->getData();
else else
out.zeros(); out.zeros();
if(maxdim==0) if(maxdim==0)
return; return;
_Ttype*last; _Ttype*last;
if(maxdim==1) if(maxdim==1)
last= new _Ttype(*(_Tparent::get(Symmetry(1)))); last= new _Ttype(*(_Tparent::get(Symmetry(1))));
else else
last= new _Ttype(*(_Tparent::get(Symmetry(maxdim))),v); last= new _Ttype(*(_Tparent::get(Symmetry(maxdim))),v);
for(int d= maxdim-1;d>=1;d--){ for(int d= maxdim-1;d>=1;d--){
Symmetry cs(d); Symmetry cs(d);
if(_Tparent::check(cs)){ if(_Tparent::check(cs)){
const _Ttype*nt= _Tparent::get(cs); const _Ttype*nt= _Tparent::get(cs);
last->add(1.0,ConstTwoDMatrix(*nt)); last->add(1.0,ConstTwoDMatrix(*nt));
} }
if(d> 1){ if(d> 1){
_Ttype*new_last= new _Ttype(*last,v); _Ttype*new_last= new _Ttype(*last,v);
delete last; delete last;
last= new_last; last= new_last;
} }
} }
last->multaVec(out,v); last->multaVec(out,v);
delete last; delete last;
} }
/*:9*/ /*:9*/
; ;
/*10:*/ /*10:*/
void insert(_ptr t) void insert(_ptr t)
{ {
TL_RAISE_IF(t->nrows()!=nr, TL_RAISE_IF(t->nrows()!=nr,
"Wrong number of rows in TensorPolynomial::insert"); "Wrong number of rows in TensorPolynomial::insert");
TL_RAISE_IF(t->nvar()!=nv, TL_RAISE_IF(t->nvar()!=nv,
"Wrong number of variables in TensorPolynomial::insert"); "Wrong number of variables in TensorPolynomial::insert");
TensorContainer<_Ttype> ::insert(t); TensorContainer<_Ttype> ::insert(t);
if(maxdim<t->dimen()) if(maxdim<t->dimen())
maxdim= t->dimen(); maxdim= t->dimen();
} }
/*:10*/ /*:10*/
; ;
/*11:*/ /*11:*/
void derivative(int k) void derivative(int k)
{ {
for(int d= 1;d<=maxdim;d++){ for(int d= 1;d<=maxdim;d++){
if(_Tparent::check(Symmetry(d))){ if(_Tparent::check(Symmetry(d))){
_Ttype*ten= _Tparent::get(Symmetry(d)); _Ttype*ten= _Tparent::get(Symmetry(d));
ten->mult((double)max((d-k),0)); ten->mult((double)max((d-k),0));
} }
} }
} }
/*:11*/ /*:11*/
; ;
/*12:*/ /*12:*/
_Ttype*evalPartially(int s,const ConstVector&v) _Ttype*evalPartially(int s,const ConstVector&v)
{ {
TL_RAISE_IF(v.length()!=nvars(), TL_RAISE_IF(v.length()!=nvars(),
"Wrong length of vector for TensorPolynomial::evalPartially"); "Wrong length of vector for TensorPolynomial::evalPartially");
_Ttype*res= new _Ttype(nrows(),nvars(),s); _Ttype*res= new _Ttype(nrows(),nvars(),s);
res->zeros(); res->zeros();
int sfac= 1; int sfac= 1;
for(int i= 1;i<=s;i++) for(int i= 1;i<=s;i++)
sfac*= i; sfac*= i;
if(_Tparent::check(Symmetry(s))) if(_Tparent::check(Symmetry(s)))
res->add(1.0/sfac,*(_Tparent::get(Symmetry(s)))); res->add(1.0/sfac,*(_Tparent::get(Symmetry(s))));
int dfac= sfac*(s+1); int dfac= sfac*(s+1);
for(int d= s+1;d<=maxdim;d++,dfac*= d){ for(int d= s+1;d<=maxdim;d++,dfac*= d){
if(_Tparent::check(Symmetry(d))){ if(_Tparent::check(Symmetry(d))){
const _Ttype&ltmp= *(_Tparent::get(Symmetry(d))); const _Ttype&ltmp= *(_Tparent::get(Symmetry(d)));
_Ttype*last= new _Ttype(ltmp); _Ttype*last= new _Ttype(ltmp);
for(int j= 0;j<d-s;j++){ for(int j= 0;j<d-s;j++){
_Ttype*newlast= new _Ttype(*last,v); _Ttype*newlast= new _Ttype(*last,v);
delete last; delete last;
last= newlast; last= newlast;
} }
res->add(1.0/dfac,*last); res->add(1.0/dfac,*last);
delete last; delete last;
} }
} }
return res; return res;
} }
/*:12*/ /*:12*/
; ;
}; };
@ -256,15 +256,15 @@ return res;
class FTensorPolynomial; class FTensorPolynomial;
class UTensorPolynomial:public TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> { class UTensorPolynomial:public TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> {
public: public:
UTensorPolynomial(int rows,int vars) UTensorPolynomial(int rows,int vars)
:TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> (rows,vars){} :TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> (rows,vars){}
UTensorPolynomial(const UTensorPolynomial&up,int k) UTensorPolynomial(const UTensorPolynomial&up,int k)
:TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> (up,k){} :TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> (up,k){}
UTensorPolynomial(const FTensorPolynomial&fp); UTensorPolynomial(const FTensorPolynomial&fp);
UTensorPolynomial(const UTensorPolynomial&tp,const Vector&xval) UTensorPolynomial(const UTensorPolynomial&tp,const Vector&xval)
:TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> (tp,xval){} :TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> (tp,xval){}
UTensorPolynomial(int first_row,int num,UTensorPolynomial&tp) UTensorPolynomial(int first_row,int num,UTensorPolynomial&tp)
:TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> (first_row,num,tp){} :TensorPolynomial<UFSTensor,UGSTensor,URSingleTensor> (first_row,num,tp){}
}; };
/*:13*/ /*:13*/
@ -273,15 +273,15 @@ UTensorPolynomial(int first_row,int num,UTensorPolynomial&tp)
class FTensorPolynomial:public TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> { class FTensorPolynomial:public TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> {
public: public:
FTensorPolynomial(int rows,int vars) FTensorPolynomial(int rows,int vars)
:TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (rows,vars){} :TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (rows,vars){}
FTensorPolynomial(const FTensorPolynomial&fp,int k) FTensorPolynomial(const FTensorPolynomial&fp,int k)
:TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (fp,k){} :TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (fp,k){}
FTensorPolynomial(const UTensorPolynomial&up); FTensorPolynomial(const UTensorPolynomial&up);
FTensorPolynomial(const FTensorPolynomial&tp,const Vector&xval) FTensorPolynomial(const FTensorPolynomial&tp,const Vector&xval)
:TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (tp,xval){} :TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (tp,xval){}
FTensorPolynomial(int first_row,int num,FTensorPolynomial&tp) FTensorPolynomial(int first_row,int num,FTensorPolynomial&tp)
:TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (first_row,num,tp){} :TensorPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (first_row,num,tp){}
}; };
/*:14*/ /*:14*/
@ -291,61 +291,61 @@ FTensorPolynomial(int first_row,int num,FTensorPolynomial&tp)
template<class _Ttype,class _TGStype,class _Stype> template<class _Ttype,class _TGStype,class _Stype>
class CompactPolynomial:public _Ttype{ class CompactPolynomial:public _Ttype{
public: public:
/*16:*/ /*16:*/
CompactPolynomial(const TensorPolynomial<_Ttype,_TGStype,_Stype> &pol) CompactPolynomial(const TensorPolynomial<_Ttype,_TGStype,_Stype> &pol)
:_Ttype(pol.nrows(),pol.nvars()+1,pol.getMaxDim()) :_Ttype(pol.nrows(),pol.nvars()+1,pol.getMaxDim())
{ {
_Ttype::zeros(); _Ttype::zeros();
IntSequence dumnvs(2); IntSequence dumnvs(2);
dumnvs[0]= 1; dumnvs[0]= 1;
dumnvs[1]= pol.nvars(); dumnvs[1]= pol.nvars();
int offset= 0; int offset= 0;
_Ttype dum(0,2,_Ttype::dimen()); _Ttype dum(0,2,_Ttype::dimen());
for(Tensor::index i= dum.begin();i!=dum.end();++i){ for(Tensor::index i= dum.begin();i!=dum.end();++i){
int d= i.getCoor().sum(); int d= i.getCoor().sum();
Symmetry symrun(_Ttype::dimen()-d,d); Symmetry symrun(_Ttype::dimen()-d,d);
_TGStype dumgs(0,TensorDimens(symrun,dumnvs)); _TGStype dumgs(0,TensorDimens(symrun,dumnvs));
if(pol.check(Symmetry(d))){ if(pol.check(Symmetry(d))){
TwoDMatrix subt(*this,offset,dumgs.ncols()); TwoDMatrix subt(*this,offset,dumgs.ncols());
subt.add(1.0,*(pol.get(Symmetry(d)))); subt.add(1.0,*(pol.get(Symmetry(d))));
} }
offset+= dumgs.ncols(); offset+= dumgs.ncols();
} }
} }
/*:16*/ /*:16*/
; ;
/*17:*/ /*17:*/
void eval(Vector&out,const ConstVector&v)const void eval(Vector&out,const ConstVector&v)const
{ {
TL_RAISE_IF(v.length()+1!=_Ttype::nvar(), TL_RAISE_IF(v.length()+1!=_Ttype::nvar(),
"Wrong input vector length in CompactPolynomial::eval"); "Wrong input vector length in CompactPolynomial::eval");
TL_RAISE_IF(out.length()!=_Ttype::nrows(), TL_RAISE_IF(out.length()!=_Ttype::nrows(),
"Wrong output vector length in CompactPolynomial::eval"); "Wrong output vector length in CompactPolynomial::eval");
Vector x1(v.length()+1); Vector x1(v.length()+1);
Vector x1p(x1,1,v.length()); Vector x1p(x1,1,v.length());
x1p= v; x1p= v;
x1[0]= 1.0; x1[0]= 1.0;
if(_Ttype::dimen()==0) if(_Ttype::dimen()==0)
out= ConstVector(*this,0); out= ConstVector(*this,0);
else{ else{
PowerProvider pp(x1); PowerProvider pp(x1);
const _Stype&xpow= pp.getNext((const _Stype*)NULL); const _Stype&xpow= pp.getNext((const _Stype*)NULL);
for(int i= 1;i<_Ttype::dimen();i++) for(int i= 1;i<_Ttype::dimen();i++)
xpow= pp.getNext((const _Stype*)NULL); xpow= pp.getNext((const _Stype*)NULL);
multVec(0.0,out,1.0,xpow); multVec(0.0,out,1.0,xpow);
} }
} }
/*:17*/ /*:17*/
; ;
}; };
/*:15*/ /*:15*/
@ -354,8 +354,8 @@ multVec(0.0,out,1.0,xpow);
class UCompactPolynomial:public CompactPolynomial<UFSTensor,UGSTensor,URSingleTensor> { class UCompactPolynomial:public CompactPolynomial<UFSTensor,UGSTensor,URSingleTensor> {
public: public:
UCompactPolynomial(const UTensorPolynomial&upol) UCompactPolynomial(const UTensorPolynomial&upol)
:CompactPolynomial<UFSTensor,UGSTensor,URSingleTensor> (upol){} :CompactPolynomial<UFSTensor,UGSTensor,URSingleTensor> (upol){}
}; };
/*:18*/ /*:18*/
@ -364,8 +364,8 @@ UCompactPolynomial(const UTensorPolynomial&upol)
class FCompactPolynomial:public CompactPolynomial<FFSTensor,FGSTensor,FRSingleTensor> { class FCompactPolynomial:public CompactPolynomial<FFSTensor,FGSTensor,FRSingleTensor> {
public: public:
FCompactPolynomial(const FTensorPolynomial&fpol) FCompactPolynomial(const FTensorPolynomial&fpol)
:CompactPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (fpol){} :CompactPolynomial<FFSTensor,FGSTensor,FRSingleTensor> (fpol){}
}; };

206
mex/sources/korderpert/Dyn_pp/tl/cc/tensor.h
View File

@ -10,36 +10,36 @@
/*2:*/ /*2:*/
template<class _Tptr> class _index{ template<class _Tptr> class _index{
typedef _index<_Tptr> _Self; typedef _index<_Tptr> _Self;
_Tptr tensor; _Tptr tensor;
int offset; int offset;
IntSequence coor; IntSequence coor;
public: public:
_index(_Tptr t,int n) _index(_Tptr t,int n)
:tensor(t),offset(0),coor(n,0){} :tensor(t),offset(0),coor(n,0){}
_index(_Tptr t,const IntSequence&cr,int c) _index(_Tptr t,const IntSequence&cr,int c)
:tensor(t),offset(c),coor(cr){} :tensor(t),offset(c),coor(cr){}
_index(_Tptr t,const IntSequence&cr) _index(_Tptr t,const IntSequence&cr)
:tensor(t),offset(tensor->getOffset(cr)),coor(cr){} :tensor(t),offset(tensor->getOffset(cr)),coor(cr){}
_index(const _index&ind) _index(const _index&ind)
:tensor(ind.tensor),offset(ind.offset),coor(ind.coor){} :tensor(ind.tensor),offset(ind.offset),coor(ind.coor){}
const _Self&operator= (const _Self&in) const _Self&operator= (const _Self&in)
{tensor= in.tensor;offset= in.offset;coor= in.coor; {tensor= in.tensor;offset= in.offset;coor= in.coor;
return*this;} return*this;}
_Self&operator++() _Self&operator++()
{tensor->increment(coor);offset++;return*this;} {tensor->increment(coor);offset++;return*this;}
_Self&operator--() _Self&operator--()
{tensor->decrement(coor);offset--;return*this;} {tensor->decrement(coor);offset--;return*this;}
int operator*()const int operator*()const
{return offset;} {return offset;}
bool operator==(const _index&n)const bool operator==(const _index&n)const
{return offset==n.offset;} {return offset==n.offset;}
bool operator!=(const _index&n)const bool operator!=(const _index&n)const
{return offset!=n.offset;} {return offset!=n.offset;}
const IntSequence&getCoor()const const IntSequence&getCoor()const
{return coor;} {return coor;}
void print()const void print()const
{printf("%4d: ",offset);coor.print();} {printf("%4d: ",offset);coor.print();}
}; };
/*:2*/ /*:2*/
@ -48,55 +48,55 @@ void print()const
class Tensor:public TwoDMatrix{ class Tensor:public TwoDMatrix{
public: public:
enum indor{along_row,along_col}; enum indor{along_row,along_col};
typedef _index<const Tensor*> index; typedef _index<const Tensor*> index;
protected: protected:
const index in_beg; const index in_beg;
const index in_end; const index in_end;
int dim; int dim;
public: public:
Tensor(indor io,const IntSequence&last,int r,int c,int d) Tensor(indor io,const IntSequence&last,int r,int c,int d)
:TwoDMatrix(r,c), :TwoDMatrix(r,c),
in_beg(this,d), in_beg(this,d),
in_end(this,last,(io==along_row)?r:c), in_end(this,last,(io==along_row)?r:c),
dim(d){} dim(d){}
Tensor(indor io,const IntSequence&first,const IntSequence&last, Tensor(indor io,const IntSequence&first,const IntSequence&last,
int r,int c,int d) int r,int c,int d)
:TwoDMatrix(r,c), :TwoDMatrix(r,c),
in_beg(this,first,0), in_beg(this,first,0),
in_end(this,last,(io==along_row)?r:c), in_end(this,last,(io==along_row)?r:c),
dim(d){} dim(d){}
Tensor(int first_row,int num,Tensor&t) Tensor(int first_row,int num,Tensor&t)
:TwoDMatrix(first_row,num,t), :TwoDMatrix(first_row,num,t),
in_beg(t.in_beg), in_beg(t.in_beg),
in_end(t.in_end), in_end(t.in_end),
dim(t.dim){} dim(t.dim){}
Tensor(const Tensor&t) Tensor(const Tensor&t)
:TwoDMatrix(t), :TwoDMatrix(t),
in_beg(this,t.in_beg.getCoor(),*(t.in_beg)), in_beg(this,t.in_beg.getCoor(),*(t.in_beg)),
in_end(this,t.in_end.getCoor(),*(t.in_end)), in_end(this,t.in_end.getCoor(),*(t.in_end)),
dim(t.dim){} dim(t.dim){}
virtual~Tensor(){} virtual~Tensor(){}
virtual void increment(IntSequence&v)const= 0; virtual void increment(IntSequence&v)const= 0;
virtual void decrement(IntSequence&v)const= 0; virtual void decrement(IntSequence&v)const= 0;
virtual int getOffset(const IntSequence&v)const= 0; virtual int getOffset(const IntSequence&v)const= 0;
int dimen()const int dimen()const
{return dim;} {return dim;}
const index&begin()const const index&begin()const
{return in_beg;} {return in_beg;}
const index&end()const const index&end()const
{return in_end;} {return in_end;}
static int noverk(int n,int k); static int noverk(int n,int k);
static int power(int a,int b); static int power(int a,int b);
static int noverseq(const IntSequence&s) static int noverseq(const IntSequence&s)
{ {
IntSequence seq(s); IntSequence seq(s);
return noverseq_ip((IntSequence&)s); return noverseq_ip((IntSequence&)s);
} }
private: private:
static int noverseq_ip(IntSequence&s); static int noverseq_ip(IntSequence&s);
}; };
/*:3*/ /*:3*/
@ -106,21 +106,21 @@ static int noverseq_ip(IntSequence&s);
class FTensor; class FTensor;
class UTensor:public Tensor{ class UTensor:public Tensor{
public: public:
UTensor(indor io,const IntSequence&last,int r,int c,int d) UTensor(indor io,const IntSequence&last,int r,int c,int d)
:Tensor(io,last,r,c,d){} :Tensor(io,last,r,c,d){}
UTensor(const UTensor&ut) UTensor(const UTensor&ut)
:Tensor(ut){} :Tensor(ut){}
UTensor(int first_row,int num,UTensor&t) UTensor(int first_row,int num,UTensor&t)
:Tensor(first_row,num,t){} :Tensor(first_row,num,t){}
virtual~UTensor(){} virtual~UTensor(){}
virtual FTensor&fold()const= 0; virtual FTensor&fold()const= 0;
static void increment(IntSequence&v,int nv); static void increment(IntSequence&v,int nv);
static void decrement(IntSequence&v,int nv); static void decrement(IntSequence&v,int nv);
static void increment(IntSequence&v,const IntSequence&nvmx); static void increment(IntSequence&v,const IntSequence&nvmx);
static void decrement(IntSequence&v,const IntSequence&nvmx); static void decrement(IntSequence&v,const IntSequence&nvmx);
static int getOffset(const IntSequence&v,int nv); static int getOffset(const IntSequence&v,int nv);
static int getOffset(const IntSequence&v,const IntSequence&nvmx); static int getOffset(const IntSequence&v,const IntSequence&nvmx);
}; };
/*:4*/ /*:4*/
@ -129,20 +129,20 @@ static int getOffset(const IntSequence&v,const IntSequence&nvmx);
class FTensor:public Tensor{ class FTensor:public Tensor{
public: public:
FTensor(indor io,const IntSequence&last,int r,int c,int d) FTensor(indor io,const IntSequence&last,int r,int c,int d)
:Tensor(io,last,r,c,d){} :Tensor(io,last,r,c,d){}
FTensor(const FTensor&ft) FTensor(const FTensor&ft)
:Tensor(ft){} :Tensor(ft){}
FTensor(int first_row,int num,FTensor&t) FTensor(int first_row,int num,FTensor&t)
:Tensor(first_row,num,t){} :Tensor(first_row,num,t){}
virtual~FTensor(){} virtual~FTensor(){}
virtual UTensor&unfold()const= 0; virtual UTensor&unfold()const= 0;
static void decrement(IntSequence&v,int nv); static void decrement(IntSequence&v,int nv);
static int getOffset(const IntSequence&v,int nv) static int getOffset(const IntSequence&v,int nv)
{IntSequence vtmp(v);return getOffsetRecurse(vtmp,nv);} {IntSequence vtmp(v);return getOffsetRecurse(vtmp,nv);}
private: private:
static int getOffsetRecurse(IntSequence&v,int nv); static int getOffsetRecurse(IntSequence&v,int nv);
}; };
/*:5*/ /*:5*/

24
mex/sources/korderpert/Dyn_pp/tl/cc/tl_exception.h
View File

@ -25,19 +25,19 @@ if (TL_DEBUG >= TL_DEBUG_EXCEPTION && (expr)) throw TLException(__FILE__, __LINE
/*3:*/ /*3:*/
class TLException{ class TLException{
char fname[50]; char fname[50];
int lnum; int lnum;
char message[500]; char message[500];
public: public:
TLException(const char*f,int l,const char*mes) TLException(const char*f,int l,const char*mes)
{ {
strncpy(fname,f,50);fname[49]= '\0'; strncpy(fname,f,50);fname[49]= '\0';
strncpy(message,mes,500);message[499]= '\0'; strncpy(message,mes,500);message[499]= '\0';
lnum= l; lnum= l;
} }
virtual~TLException(){} virtual~TLException(){}
virtual void print()const virtual void print()const
{printf("At %s:%d:%s\n",fname,lnum,message);} {printf("At %s:%d:%s\n",fname,lnum,message);}
}; };