MPQC  2.3.1
elemop.h
1 //
2 // elemop.h
3 //
4 // Copyright (C) 1996 Limit Point Systems, Inc.
5 //
6 // Author: Curtis Janssen <cljanss@limitpt.com>
7 // Maintainer: LPS
8 //
9 // This file is part of the SC Toolkit.
10 //
11 // The SC Toolkit is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU Library General Public License as published by
13 // the Free Software Foundation; either version 2, or (at your option)
14 // any later version.
15 //
16 // The SC Toolkit is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU Library General Public License for more details.
20 //
21 // You should have received a copy of the GNU Library General Public License
22 // along with the SC Toolkit; see the file COPYING.LIB. If not, write to
23 // the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24 //
25 // The U.S. Government is granted a limited license as per AL 91-7.
26 //
27 
28 #ifndef _math_scmat_elemop_h
29 #define _math_scmat_elemop_h
30 
31 #ifdef __GNUC__
32 #pragma interface
33 #endif
34 
35 #include <util/state/state.h>
36 #include <util/group/message.h>
37 
38 namespace sc {
39 
40 class SCMatrixBlock;
41 class SCMatrixBlockIter;
42 class SCMatrixRectBlock;
43 class SCMatrixLTriBlock;
44 class SCMatrixDiagBlock;
45 class SCVectorSimpleBlock;
46 class SCMatrixRectSubBlock;
47 class SCMatrixLTriSubBlock;
48 class SCMatrixDiagSubBlock;
49 class SCVectorSimpleSubBlock;
50 
51 class SCMatrix;
52 class SymmSCMatrix;
53 class DiagSCMatrix;
54 class SCVector;
55 
60 class SCElementOp: public SavableState {
61  public:
62  SCElementOp();
64  virtual ~SCElementOp();
72  virtual int has_collect();
73  virtual void defer_collect(int);
74  virtual void collect(const Ref<MessageGrp>&);
78  virtual void collect(const Ref<SCElementOp>&);
82  virtual int has_side_effects();
83 
86  virtual bool threadsafe();
87 
90  virtual bool cloneable();
91 
95  virtual Ref<SCElementOp> clone();
96 
99  virtual void process(SCMatrixBlockIter&) = 0;
100 
105  void process_base(SCMatrixBlock*block);
106 
111  virtual void process_spec_rect(SCMatrixRectBlock*);
112  virtual void process_spec_ltri(SCMatrixLTriBlock*);
113  virtual void process_spec_diag(SCMatrixDiagBlock*);
114  virtual void process_spec_vsimp(SCVectorSimpleBlock*);
115  virtual void process_spec_rectsub(SCMatrixRectSubBlock*);
116  virtual void process_spec_ltrisub(SCMatrixLTriSubBlock*);
117  virtual void process_spec_diagsub(SCMatrixDiagSubBlock*);
118  virtual void process_spec_vsimpsub(SCVectorSimpleSubBlock*);
119 };
120 
125 class SCElementOp2: public SavableState {
126  public:
127  SCElementOp2();
129  virtual ~SCElementOp2();
130  virtual int has_collect();
131  virtual void defer_collect(int);
132  virtual int has_side_effects();
133  virtual int has_side_effects_in_arg();
134  virtual void collect(const Ref<MessageGrp>&);
135  virtual void process(SCMatrixBlockIter&,SCMatrixBlockIter&) = 0;
136  void process_base(SCMatrixBlock*,SCMatrixBlock*);
137  virtual void process_spec_rect(SCMatrixRectBlock*,SCMatrixRectBlock*);
138  virtual void process_spec_ltri(SCMatrixLTriBlock*,SCMatrixLTriBlock*);
139  virtual void process_spec_diag(SCMatrixDiagBlock*,SCMatrixDiagBlock*);
140  virtual void process_spec_vsimp(SCVectorSimpleBlock*,SCVectorSimpleBlock*);
141 };
142 
147 class SCElementOp3: public SavableState {
148  public:
149  SCElementOp3();
151  virtual ~SCElementOp3();
152  virtual int has_collect();
153  virtual void defer_collect(int);
154  virtual int has_side_effects();
155  virtual int has_side_effects_in_arg1();
156  virtual int has_side_effects_in_arg2();
157  virtual void collect(const Ref<MessageGrp>&);
158  virtual void process(SCMatrixBlockIter&,
160  SCMatrixBlockIter&) = 0;
161  void process_base(SCMatrixBlock*,SCMatrixBlock*,SCMatrixBlock*);
162  virtual void process_spec_rect(SCMatrixRectBlock*,
165  virtual void process_spec_ltri(SCMatrixLTriBlock*,
168  virtual void process_spec_diag(SCMatrixDiagBlock*,
171  virtual void process_spec_vsimp(SCVectorSimpleBlock*,
174 };
175 
177  private:
178  int deferred_;
179  double product;
180  public:
184  void save_data_state(StateOut&);
185  void process(SCMatrixBlockIter&,SCMatrixBlockIter&);
186  int has_collect();
187  void defer_collect(int);
188  void collect(const Ref<MessageGrp>&);
189  double result();
190  void init() { product = 0.0; }
191 };
192 
193 
195  public:
199  int has_side_effects();
200  void save_data_state(StateOut&);
201  void process(SCMatrixBlockIter&,SCMatrixBlockIter&);
202 };
203 
205  private:
206  double scale;
207  public:
208  SCElementScale(double a);
210  ~SCElementScale();
211  int has_side_effects();
212  void save_data_state(StateOut&);
213  void process(SCMatrixBlockIter&);
214 };
215 
217  private:
218  double assign;
219  public:
223  int has_side_effects();
224  void save_data_state(StateOut&);
225  void process(SCMatrixBlockIter&);
226 };
227 
229  private:
230  double assign;
231  public:
232  SCElementAssign(double a);
234  ~SCElementAssign();
235  int has_side_effects();
236  void save_data_state(StateOut&);
237  void process(SCMatrixBlockIter&);
238 };
239 
241  public:
243  SCElementSquareRoot(double a);
246  int has_side_effects();
247  void save_data_state(StateOut&);
248  void process(SCMatrixBlockIter&);
249 };
250 
252  private:
253  double threshold_;
254  int nbelowthreshold_;
255  int deferred_;
256  public:
257  SCElementInvert(double threshold = 0.0);
259  ~SCElementInvert();
260  int has_side_effects();
261  void save_data_state(StateOut&);
262  void process(SCMatrixBlockIter&);
263  int has_collect();
264  void defer_collect(int);
265  void collect(const Ref<MessageGrp>&);
266  void collect(const Ref<SCElementOp>&);
267  int result() { return nbelowthreshold_; }
268 };
269 
270 
272  private:
273  double scale_diagonal;
274  public:
275  SCElementScaleDiagonal(double a);
278  int has_side_effects();
279  void save_data_state(StateOut&);
280  void process(SCMatrixBlockIter&);
281 };
282 
284  private:
285  double shift_diagonal;
286  public:
287  SCElementShiftDiagonal(double a);
290  int has_side_effects();
291  void save_data_state(StateOut&);
292  void process(SCMatrixBlockIter&);
293 };
294 
296  private:
297  int deferred_;
298  double r;
299  public:
300  SCElementMaxAbs();
302  ~SCElementMaxAbs();
303  void save_data_state(StateOut&);
304  void process(SCMatrixBlockIter&);
305  int has_collect();
306  void defer_collect(int);
307  void collect(const Ref<MessageGrp>&);
308  void collect(const Ref<SCElementOp>&);
309  double result();
310 };
311 
312 
314  private:
315  int deferred_;
316  double r;
317  public:
318  // rinit must be greater than the magnitude of the smallest element
319  SCElementMinAbs(double rinit);
321  ~SCElementMinAbs();
322  void save_data_state(StateOut&);
323  void process(SCMatrixBlockIter&);
324  int has_collect();
325  void defer_collect(int);
326  void collect(const Ref<MessageGrp>&);
327  void collect(const Ref<SCElementOp>&);
328  double result();
329 };
330 
331 
333  private:
334  int deferred_;
335  double r;
336  public:
337  SCElementSumAbs();
339  ~SCElementSumAbs();
340  void save_data_state(StateOut&);
341  void process(SCMatrixBlockIter&);
342  int has_collect();
343  void defer_collect(int);
344  void collect(const Ref<MessageGrp>&);
345  void collect(const Ref<SCElementOp>&);
346  double result();
347  void init() { r = 0.0; }
348 };
349 
352  private:
353  int deferred_;
354  double r_; // result
355  double k_; // norm parameter
356  public:
358  SCElementKNorm(double k = 2.0);
360  ~SCElementKNorm();
361  void save_data_state(StateOut&);
362  void process(SCMatrixBlockIter&);
363  int has_collect();
364  void defer_collect(int);
365  void collect(const Ref<MessageGrp>&);
366  void collect(const Ref<SCElementOp>&);
367  double result();
368  void init() { r_ = 0.0; }
369 };
370 
371 class SCElementDot: public SCElementOp {
372  private:
373  double** avects;
374  double** bvects;
375  int length;
376  public:
378  void save_data_state(StateOut&);
379  SCElementDot(double**a, double**b, int length);
380  void process(SCMatrixBlockIter&);
381  int has_side_effects();
382 };
383 
385  private:
386  SCMatrix *m;
387  public:
389  int has_side_effects();
390  void process(SCMatrixBlockIter&);
391 };
392 
394  private:
395  SymmSCMatrix *m;
396  public:
398  int has_side_effects();
399  void process(SCMatrixBlockIter&);
400 };
401 
403  private:
404  DiagSCMatrix *m;
405  public:
407  int has_side_effects();
408  void process(SCMatrixBlockIter&);
409 };
410 
412  private:
413  SCVector *m;
414  public:
416  int has_side_effects();
417  void process(SCMatrixBlockIter&);
418 };
419 
420 }
421 
422 #endif
423 
424 // Local Variables:
425 // mode: c++
426 // c-file-style: "CLJ"
427 // End:
int has_side_effects()
By default this returns nonzero.
int has_collect()
If duplicates of the SCElementOp exist (that is, there is more than one node), then if has_collect re...
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
int has_side_effects()
By default this returns nonzero.
Computed k-norm of matrix.
Definition: elemop.h:351
int has_collect()
If duplicates of the SCElementOp exist (that is, there is more than one node), then if has_collect re...
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
int has_side_effects()
By default this returns nonzero.
Definition: elemop.h:176
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
Definition: elemop.h:384
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
virtual bool cloneable()
Returns true if this SCElementOp supports the cloneable member.
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
Definition: elemop.h:393
Definition: elemop.h:228
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
Serializes objects that derive from SavableState.
Definition: stateout.h:61
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
virtual void process_spec_rect(SCMatrixRectBlock *)
Matrices should call these members when the type of block is known.
int has_side_effects()
By default this returns nonzero.
Definition: elemop.h:371
The SCMatrix class is the abstract base class for general double valued n by m matrices.
Definition: abstract.h:195
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
Definition: elemop.h:271
The SCMatrixRectBlock describes a rectangular piece of a matrix.
Definition: block.h:187
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
The SCVectorSimpleBlock describes a piece of a vector.
Definition: block.h:127
A template class that maintains references counts.
Definition: ref.h:332
SCMatrixBlock is the base clase for all types of blocks that comprise matrices and vectors...
Definition: block.h:45
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
The SCMatrixRectSubBlock describes a rectangular piece of a matrix.
Definition: block.h:223
int has_side_effects()
By default this returns nonzero.
virtual Ref< SCElementOp > clone()
Returns a clone of this object.
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
Definition: elemop.h:204
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
int has_collect()
If duplicates of the SCElementOp exist (that is, there is more than one node), then if has_collect re...
Definition: elemop.h:240
The SymmSCMatrix class is the abstract base class for diagonal double valued matrices.
Definition: abstract.h:503
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
Definition: mpqcin.h:13
Definition: elemop.h:402
The SCMatrixDiagSubBlock describes a diagonal subblock of a matrix.
Definition: block.h:355
int has_side_effects()
By default this returns nonzero.
int has_side_effects()
By default this returns nonzero.
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
The SCVector class is the abstract base class for double valued vectors.
Definition: abstract.h:97
Restores objects that derive from SavableState.
Definition: statein.h:70
int has_side_effects()
By default this returns nonzero.
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
Definition: elemop.h:283
The SCElementOp2 class is very similar to the SCElementOp class except that pairs of blocks are treat...
Definition: elemop.h:125
int has_collect()
If duplicates of the SCElementOp exist (that is, there is more than one node), then if has_collect re...
int has_side_effects()
By default this returns nonzero.
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
The SCVectorSimpleSubBlock describes a subblock of a vector.
Definition: block.h:158
Definition: elemop.h:251
The SCMatrixLTriBlock describes a triangular piece of a matrix.
Definition: block.h:257
Definition: elemop.h:411
The SymmSCMatrix class is the abstract base class for symmetric double valued matrices.
Definition: abstract.h:364
SCElementKNorm(double k=2.0)
by default compute 2-norm
virtual void process(SCMatrixBlockIter &)=0
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
Definition: elemop.h:194
Definition: elemop.h:216
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
int has_side_effects()
By default this returns nonzero.
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
int has_collect()
If duplicates of the SCElementOp exist (that is, there is more than one node), then if has_collect re...
Definition: elemop.h:332
virtual int has_collect()
If duplicates of the SCElementOp exist (that is, there is more than one node), then if has_collect re...
int has_side_effects()
By default this returns nonzero.
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
The SCElementOp3 class is very similar to the SCElementOp class except that a triplet of blocks is tr...
Definition: elemop.h:147
void process_base(SCMatrixBlock *block)
Lazy matrix implementors can call this member when the type of block specialization is unknown...
The SCMatrixLTriSubBlock describes a triangular subblock of a matrix.
Definition: block.h:292
Definition: elemop.h:313
virtual bool threadsafe()
Returns true if this SCElementOp is threadsafe.
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
Definition: elemop.h:295
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
int has_side_effects()
By default this returns nonzero.
Objects of class SCElementOp are used to perform operations on the elements of matrices.
Definition: elemop.h:60
virtual int has_side_effects()
By default this returns nonzero.
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
Base class for objects that can save/restore state.
Definition: state.h:46
The SCMatrixBlockIter class is used to described iterates that loop through the elements in a block...
Definition: blkiter.h:50
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
The SCMatrixDiagBlock describes a diagonal piece of a matrix.
Definition: block.h:322

Generated at Fri Feb 16 2018 01:48:56 for MPQC 2.3.1 using the documentation package Doxygen 1.8.14.