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