Main Page Class Hierarchy Compound List File List Compound Members Related Pages

# elemop.h

    00001 //
    00002 // elemop.h
    00003 //
    00004 // Copyright (C) 1996 Limit Point Systems, Inc.
    00005 //
    00006 // Author: Curtis Janssen <cljanss@limitpt.com>
    00007 // Maintainer: LPS
    00008 //
    00009 // This file is part of the SC Toolkit.
    00010 //
    00011 // The SC Toolkit is free software; you can redistribute it and/or modify
    00012 // it under the terms of the GNU Library General Public License as published by
    00013 // the Free Software Foundation; either version 2, or (at your option)
    00014 // any later version.
    00015 //
    00016 // The SC Toolkit is distributed in the hope that it will be useful,
    00017 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00019 // GNU Library General Public License for more details.
    00020 //
    00021 // You should have received a copy of the GNU Library General Public License
    00022 // along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
    00023 // the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
    00024 //
    00025 // The U.S. Government is granted a limited license as per AL 91-7.
    00026 //
    00027
    00028 #ifndef _math_scmat_elemop_h
    00029 #define _math_scmat_elemop_h
    00030
    00031 #ifdef __GNUC__
    00032 #pragma interface
    00033 #endif
    00034
    00035 #include <util/state/state.h>
    00036 #include <util/group/message.h>
    00037
    00038 namespace sc {
    00039
    00040 class SCMatrixBlock;
    00041 class SCMatrixBlockIter;
    00042 class SCMatrixRectBlock;
    00043 class SCMatrixLTriBlock;
    00044 class SCMatrixDiagBlock;
    00045 class SCVectorSimpleBlock;
    00046 class SCMatrixRectSubBlock;
    00047 class SCMatrixLTriSubBlock;
    00048 class SCMatrixDiagSubBlock;
    00049 class SCVectorSimpleSubBlock;
    00050
    00051 class SCMatrix;
    00052 class SymmSCMatrix;
    00053 class DiagSCMatrix;
    00054 class SCVector;
    00055
    00060 class SCElementOp: public SavableState {
    00061   public:
    00062     SCElementOp();
    00063     SCElementOp(StateIn&s): SavableState(s) {}
    00064     virtual ~SCElementOp();
    00072     virtual int has_collect();
    00073     virtual void defer_collect(int);
    00074     virtual void collect(const Ref<MessageGrp>&);
    00078     virtual void collect(const Ref<SCElementOp>&);
    00082     virtual int has_side_effects();
    00083
    00086     virtual bool threadsafe();
    00087
    00090     virtual bool cloneable();
    00091
    00095     virtual Ref<SCElementOp> clone();
    00096
    00099     virtual void process(SCMatrixBlockIter&) = 0;
    00100
    00105     void process_base(SCMatrixBlock*block);
    00106
    00111     virtual void process_spec_rect(SCMatrixRectBlock*);
    00112     virtual void process_spec_ltri(SCMatrixLTriBlock*);
    00113     virtual void process_spec_diag(SCMatrixDiagBlock*);
    00114     virtual void process_spec_vsimp(SCVectorSimpleBlock*);
    00115     virtual void process_spec_rectsub(SCMatrixRectSubBlock*);
    00116     virtual void process_spec_ltrisub(SCMatrixLTriSubBlock*);
    00117     virtual void process_spec_diagsub(SCMatrixDiagSubBlock*);
    00118     virtual void process_spec_vsimpsub(SCVectorSimpleSubBlock*);
    00119 };
    00120
    00125 class SCElementOp2: public SavableState {
    00126   public:
    00127     SCElementOp2();
    00128     SCElementOp2(StateIn&s): SavableState(s) {}
    00129     virtual ~SCElementOp2();
    00130     virtual int has_collect();
    00131     virtual void defer_collect(int);
    00132     virtual int has_side_effects();
    00133     virtual int has_side_effects_in_arg();
    00134     virtual void collect(const Ref<MessageGrp>&);
    00135     virtual void process(SCMatrixBlockIter&,SCMatrixBlockIter&) = 0;
    00136     void process_base(SCMatrixBlock*,SCMatrixBlock*);
    00137     virtual void process_spec_rect(SCMatrixRectBlock*,SCMatrixRectBlock*);
    00138     virtual void process_spec_ltri(SCMatrixLTriBlock*,SCMatrixLTriBlock*);
    00139     virtual void process_spec_diag(SCMatrixDiagBlock*,SCMatrixDiagBlock*);
    00140     virtual void process_spec_vsimp(SCVectorSimpleBlock*,SCVectorSimpleBlock*);
    00141 };
    00142
    00147 class SCElementOp3: public SavableState {
    00148   public:
    00149     SCElementOp3();
    00150     SCElementOp3(StateIn&s): SavableState(s) {}
    00151     virtual ~SCElementOp3();
    00152     virtual int has_collect();
    00153     virtual void defer_collect(int);
    00154     virtual int has_side_effects();
    00155     virtual int has_side_effects_in_arg1();
    00156     virtual int has_side_effects_in_arg2();
    00157     virtual void collect(const Ref<MessageGrp>&);
    00158     virtual void process(SCMatrixBlockIter&,
    00159                          SCMatrixBlockIter&,
    00160                          SCMatrixBlockIter&) = 0;
    00161     void process_base(SCMatrixBlock*,SCMatrixBlock*,SCMatrixBlock*);
    00162     virtual void process_spec_rect(SCMatrixRectBlock*,
    00163                                    SCMatrixRectBlock*,
    00164                                    SCMatrixRectBlock*);
    00165     virtual void process_spec_ltri(SCMatrixLTriBlock*,
    00166                                    SCMatrixLTriBlock*,
    00167                                    SCMatrixLTriBlock*);
    00168     virtual void process_spec_diag(SCMatrixDiagBlock*,
    00169                                    SCMatrixDiagBlock*,
    00170                                    SCMatrixDiagBlock*);
    00171     virtual void process_spec_vsimp(SCVectorSimpleBlock*,
    00172                                     SCVectorSimpleBlock*,
    00173                                     SCVectorSimpleBlock*);
    00174 };
    00175
    00176 class SCElementScalarProduct: public SCElementOp2 {
    00177   private:
    00178     int deferred_;
    00179     double product;
    00180   public:
    00181     SCElementScalarProduct();
    00182     SCElementScalarProduct(StateIn&);
    00183     ~SCElementScalarProduct();
    00184     void save_data_state(StateOut&);
    00185     void process(SCMatrixBlockIter&,SCMatrixBlockIter&);
    00186     int has_collect();
    00187     void defer_collect(int);
    00188     void collect(const Ref<MessageGrp>&);
    00189     double result();
    00190     void init() { product = 0.0; }
    00191 };
    00192
    00193
    00194 class SCDestructiveElementProduct: public SCElementOp2 {
    00195   public:
    00196     SCDestructiveElementProduct();
    00197     SCDestructiveElementProduct(StateIn&);
    00198     ~SCDestructiveElementProduct();
    00199     int has_side_effects();
    00200     void save_data_state(StateOut&);
    00201     void process(SCMatrixBlockIter&,SCMatrixBlockIter&);
    00202 };
    00203
    00204 class SCElementScale: public SCElementOp {
    00205   private:
    00206     double scale;
    00207   public:
    00208     SCElementScale(double a);
    00209     SCElementScale(StateIn&);
    00210     ~SCElementScale();
    00211     int has_side_effects();
    00212     void save_data_state(StateOut&);
    00213     void process(SCMatrixBlockIter&);
    00214 };
    00215
    00216 class SCElementRandomize: public SCElementOp {
    00217   private:
    00218     double assign;
    00219   public:
    00220     SCElementRandomize();
    00221     SCElementRandomize(StateIn&);
    00222     ~SCElementRandomize();
    00223     int has_side_effects();
    00224     void save_data_state(StateOut&);
    00225     void process(SCMatrixBlockIter&);
    00226 };
    00227
    00228 class SCElementAssign: public SCElementOp {
    00229   private:
    00230     double assign;
    00231   public:
    00232     SCElementAssign(double a);
    00233     SCElementAssign(StateIn&);
    00234     ~SCElementAssign();
    00235     int has_side_effects();
    00236     void save_data_state(StateOut&);
    00237     void process(SCMatrixBlockIter&);
    00238 };
    00239
    00240 class SCElementSquareRoot: public SCElementOp {
    00241   public:
    00242     SCElementSquareRoot();
    00243     SCElementSquareRoot(double a);
    00244     SCElementSquareRoot(StateIn&);
    00245     ~SCElementSquareRoot();
    00246     int has_side_effects();
    00247     void save_data_state(StateOut&);
    00248     void process(SCMatrixBlockIter&);
    00249 };
    00250
    00251 class SCElementInvert: public SCElementOp {
    00252   private:
    00253     double threshold_;
    00254     int nbelowthreshold_;
    00255     int deferred_;
    00256   public:
    00257     SCElementInvert(double threshold = 0.0);
    00258     SCElementInvert(StateIn&);
    00259     ~SCElementInvert();
    00260     int has_side_effects();
    00261     void save_data_state(StateOut&);
    00262     void process(SCMatrixBlockIter&);
    00263     int has_collect();
    00264     void defer_collect(int);
    00265     void collect(const Ref<MessageGrp>&);
    00266     int result() { return nbelowthreshold_; }
    00267 };
    00268
    00269
    00270 class SCElementScaleDiagonal: public SCElementOp {
    00271   private:
    00272     double scale_diagonal;
    00273   public:
    00274     SCElementScaleDiagonal(double a);
    00275     SCElementScaleDiagonal(StateIn&);
    00276     ~SCElementScaleDiagonal();
    00277     int has_side_effects();
    00278     void save_data_state(StateOut&);
    00279     void process(SCMatrixBlockIter&);
    00280 };
    00281
    00282 class SCElementShiftDiagonal: public SCElementOp {
    00283   private:
    00284     double shift_diagonal;
    00285   public:
    00286     SCElementShiftDiagonal(double a);
    00287     SCElementShiftDiagonal(StateIn&);
    00288     ~SCElementShiftDiagonal();
    00289     int has_side_effects();
    00290     void save_data_state(StateOut&);
    00291     void process(SCMatrixBlockIter&);
    00292 };
    00293
    00294 class SCElementMaxAbs: public SCElementOp {
    00295   private:
    00296     int deferred_;
    00297     double r;
    00298   public:
    00299     SCElementMaxAbs();
    00300     SCElementMaxAbs(StateIn&);
    00301     ~SCElementMaxAbs();
    00302     void save_data_state(StateOut&);
    00303     void process(SCMatrixBlockIter&);
    00304     int has_collect();
    00305     void defer_collect(int);
    00306     void collect(const Ref<MessageGrp>&);
    00307     double result();
    00308 };
    00309
    00310
    00311 class SCElementMinAbs: public SCElementOp {
    00312   private:
    00313     int deferred_;
    00314     double r;
    00315   public:
    00316     // rinit must be greater than the magnitude of the smallest element
    00317     SCElementMinAbs(double rinit);
    00318     SCElementMinAbs(StateIn&);
    00319     ~SCElementMinAbs();
    00320     void save_data_state(StateOut&);
    00321     void process(SCMatrixBlockIter&);
    00322     int has_collect();
    00323     void defer_collect(int);
    00324     void collect(const Ref<MessageGrp>&);
    00325     double result();
    00326 };
    00327
    00328
    00329 class SCElementSumAbs: public SCElementOp {
    00330   private:
    00331     int deferred_;
    00332     double r;
    00333   public:
    00334     SCElementSumAbs();
    00335     SCElementSumAbs(StateIn&);
    00336     ~SCElementSumAbs();
    00337     void save_data_state(StateOut&);
    00338     void process(SCMatrixBlockIter&);
    00339     int has_collect();
    00340     void defer_collect(int);
    00341     void collect(const Ref<MessageGrp>&);
    00342     double result();
    00343     void init() { r = 0.0; }
    00344 };
    00345
    00346
    00347 class SCElementDot: public SCElementOp {
    00348   private:
    00349     double** avects;
    00350     double** bvects;
    00351     int length;
    00352   public:
    00353     SCElementDot(StateIn&);
    00354     void save_data_state(StateOut&);
    00355     SCElementDot(double**a, double**b, int length);
    00356     void process(SCMatrixBlockIter&);
    00357     int has_side_effects();
    00358 };
    00359
    00360 class SCElementAccumulateSCMatrix: public SCElementOp {
    00361   private:
    00362     SCMatrix *m;
    00363   public:
    00364     SCElementAccumulateSCMatrix(SCMatrix *);
    00365     int has_side_effects();
    00366     void process(SCMatrixBlockIter&);
    00367 };
    00368
    00369 class SCElementAccumulateSymmSCMatrix: public SCElementOp {
    00370   private:
    00371     SymmSCMatrix *m;
    00372   public:
    00373     SCElementAccumulateSymmSCMatrix(SymmSCMatrix *);
    00374     int has_side_effects();
    00375     void process(SCMatrixBlockIter&);
    00376 };
    00377
    00378 class SCElementAccumulateDiagSCMatrix: public SCElementOp {
    00379   private:
    00380     DiagSCMatrix *m;
    00381   public:
    00382     SCElementAccumulateDiagSCMatrix(DiagSCMatrix *);
    00383     int has_side_effects();
    00384     void process(SCMatrixBlockIter&);
    00385 };
    00386
    00387 class SCElementAccumulateSCVector: public SCElementOp {
    00388   private:
    00389     SCVector *m;
    00390   public:
    00391     SCElementAccumulateSCVector(SCVector *);
    00392     int has_side_effects();
    00393     void process(SCMatrixBlockIter&);
    00394 };
    00395
    00396 }
    00397
    00398 #endif
    00399
    00400 // Local Variables:
    00401 // mode: c++
    00402 // c-file-style: "CLJ"
    00403 // End: