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
00350
00351
class SCElementDot:
public SCElementOp {
00352
private:
00353
double** avects;
00354
double** bvects;
00355
int length;
00356
public:
00357 SCElementDot(StateIn&);
00358
void save_data_state(StateOut&);
00359 SCElementDot(
double**a,
double**b,
int length);
00360
void process(SCMatrixBlockIter&);
00361
int has_side_effects();
00362 };
00363
00364
class SCElementAccumulateSCMatrix:
public SCElementOp {
00365
private:
00366 SCMatrix *m;
00367
public:
00368 SCElementAccumulateSCMatrix(SCMatrix *);
00369
int has_side_effects();
00370
void process(SCMatrixBlockIter&);
00371 };
00372
00373
class SCElementAccumulateSymmSCMatrix:
public SCElementOp {
00374
private:
00375 SymmSCMatrix *m;
00376
public:
00377 SCElementAccumulateSymmSCMatrix(SymmSCMatrix *);
00378
int has_side_effects();
00379
void process(SCMatrixBlockIter&);
00380 };
00381
00382
class SCElementAccumulateDiagSCMatrix:
public SCElementOp {
00383
private:
00384 DiagSCMatrix *m;
00385
public:
00386 SCElementAccumulateDiagSCMatrix(DiagSCMatrix *);
00387
int has_side_effects();
00388
void process(SCMatrixBlockIter&);
00389 };
00390
00391
class SCElementAccumulateSCVector:
public SCElementOp {
00392
private:
00393 SCVector *m;
00394
public:
00395 SCElementAccumulateSCVector(SCVector *);
00396
int has_side_effects();
00397
void process(SCMatrixBlockIter&);
00398 };
00399
00400 }
00401
00402
#endif
00403
00404
00405
00406
00407