00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
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
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
00401
00402
00403