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 void collect(const Ref<SCElementOp>&);
00267 int result() { return nbelowthreshold_; }
00268 };
00269
00270
00271 class SCElementScaleDiagonal: public SCElementOp {
00272 private:
00273 double scale_diagonal;
00274 public:
00275 SCElementScaleDiagonal(double a);
00276 SCElementScaleDiagonal(StateIn&);
00277 ~SCElementScaleDiagonal();
00278 int has_side_effects();
00279 void save_data_state(StateOut&);
00280 void process(SCMatrixBlockIter&);
00281 };
00282
00283 class SCElementShiftDiagonal: public SCElementOp {
00284 private:
00285 double shift_diagonal;
00286 public:
00287 SCElementShiftDiagonal(double a);
00288 SCElementShiftDiagonal(StateIn&);
00289 ~SCElementShiftDiagonal();
00290 int has_side_effects();
00291 void save_data_state(StateOut&);
00292 void process(SCMatrixBlockIter&);
00293 };
00294
00295 class SCElementMaxAbs: public SCElementOp {
00296 private:
00297 int deferred_;
00298 double r;
00299 public:
00300 SCElementMaxAbs();
00301 SCElementMaxAbs(StateIn&);
00302 ~SCElementMaxAbs();
00303 void save_data_state(StateOut&);
00304 void process(SCMatrixBlockIter&);
00305 int has_collect();
00306 void defer_collect(int);
00307 void collect(const Ref<MessageGrp>&);
00308 void collect(const Ref<SCElementOp>&);
00309 double result();
00310 };
00311
00312
00313 class SCElementMinAbs: public SCElementOp {
00314 private:
00315 int deferred_;
00316 double r;
00317 public:
00318
00319 SCElementMinAbs(double rinit);
00320 SCElementMinAbs(StateIn&);
00321 ~SCElementMinAbs();
00322 void save_data_state(StateOut&);
00323 void process(SCMatrixBlockIter&);
00324 int has_collect();
00325 void defer_collect(int);
00326 void collect(const Ref<MessageGrp>&);
00327 void collect(const Ref<SCElementOp>&);
00328 double result();
00329 };
00330
00331
00332 class SCElementSumAbs: public SCElementOp {
00333 private:
00334 int deferred_;
00335 double r;
00336 public:
00337 SCElementSumAbs();
00338 SCElementSumAbs(StateIn&);
00339 ~SCElementSumAbs();
00340 void save_data_state(StateOut&);
00341 void process(SCMatrixBlockIter&);
00342 int has_collect();
00343 void defer_collect(int);
00344 void collect(const Ref<MessageGrp>&);
00345 void collect(const Ref<SCElementOp>&);
00346 double result();
00347 void init() { r = 0.0; }
00348 };
00349
00351 class SCElementKNorm: public SCElementOp {
00352 private:
00353 int deferred_;
00354 double r_;
00355 double k_;
00356 public:
00358 SCElementKNorm(double k = 2.0);
00359 SCElementKNorm(StateIn&);
00360 ~SCElementKNorm();
00361 void save_data_state(StateOut&);
00362 void process(SCMatrixBlockIter&);
00363 int has_collect();
00364 void defer_collect(int);
00365 void collect(const Ref<MessageGrp>&);
00366 void collect(const Ref<SCElementOp>&);
00367 double result();
00368 void init() { r_ = 0.0; }
00369 };
00370
00371 class SCElementDot: public SCElementOp {
00372 private:
00373 double** avects;
00374 double** bvects;
00375 int length;
00376 public:
00377 SCElementDot(StateIn&);
00378 void save_data_state(StateOut&);
00379 SCElementDot(double**a, double**b, int length);
00380 void process(SCMatrixBlockIter&);
00381 int has_side_effects();
00382 };
00383
00384 class SCElementAccumulateSCMatrix: public SCElementOp {
00385 private:
00386 SCMatrix *m;
00387 public:
00388 SCElementAccumulateSCMatrix(SCMatrix *);
00389 int has_side_effects();
00390 void process(SCMatrixBlockIter&);
00391 };
00392
00393 class SCElementAccumulateSymmSCMatrix: public SCElementOp {
00394 private:
00395 SymmSCMatrix *m;
00396 public:
00397 SCElementAccumulateSymmSCMatrix(SymmSCMatrix *);
00398 int has_side_effects();
00399 void process(SCMatrixBlockIter&);
00400 };
00401
00402 class SCElementAccumulateDiagSCMatrix: public SCElementOp {
00403 private:
00404 DiagSCMatrix *m;
00405 public:
00406 SCElementAccumulateDiagSCMatrix(DiagSCMatrix *);
00407 int has_side_effects();
00408 void process(SCMatrixBlockIter&);
00409 };
00410
00411 class SCElementAccumulateSCVector: public SCElementOp {
00412 private:
00413 SCVector *m;
00414 public:
00415 SCElementAccumulateSCVector(SCVector *);
00416 int has_side_effects();
00417 void process(SCMatrixBlockIter&);
00418 };
00419
00420 }
00421
00422 #endif
00423
00424
00425
00426
00427