Simbody 3.7
Loading...
Searching...
No Matches
MatrixCharacteristics.h
Go to the documentation of this file.
1#ifndef SimTK_SIMMATRIX_MATRIX_CHARACTERISTICS_H_
2#define SimTK_SIMMATRIX_MATRIX_CHARACTERISTICS_H_
3
4/* -------------------------------------------------------------------------- *
5 * Simbody(tm): SimTKcommon *
6 * -------------------------------------------------------------------------- *
7 * This is part of the SimTK biosimulation toolkit originating from *
8 * Simbios, the NIH National Center for Physics-Based Simulation of *
9 * Biological Structures at Stanford, funded under the NIH Roadmap for *
10 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody. *
11 * *
12 * Portions copyright (c) 2005-13 Stanford University and the Authors. *
13 * Authors: Michael Sherman *
14 * Contributors: *
15 * *
16 * Licensed under the Apache License, Version 2.0 (the "License"); you may *
17 * not use this file except in compliance with the License. You may obtain a *
18 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0. *
19 * *
20 * Unless required by applicable law or agreed to in writing, software *
21 * distributed under the License is distributed on an "AS IS" BASIS, *
22 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
23 * See the License for the specific language governing permissions and *
24 * limitations under the License. *
25 * -------------------------------------------------------------------------- */
26
33#include "SimTKcommon/Scalar.h"
34
35#include <iostream>
36#include <cassert>
37#include <complex>
38#include <cstddef>
39#include <utility> // for std::pair
40
41namespace SimTK {
42
43
44class MatrixStructure;
45class MatrixStorage;
46class MatrixOutline;
47class MatrixCondition;
48class MatrixCharacter;
49class MatrixCommitment;
50
51
52// ------------------------------ MatrixStructure -----------------------------
57// ----------------------------------------------------------------------------
59public:
60 enum Structure {
61 NoStructure = 0x00000000,
62 Matrix1d = 0x00000001,
63 Zero = 0x00000002,
64 Identity = 0x00000004,
65 Permutation = 0x00000008,
66 RepeatedDiagonal = 0x00000010,
67 Diagonal = 0x00000020,
68 BiDiagonal = 0x00000040,
69 TriDiagonal = 0x00000080,
70 BandedSymmetric = 0x00000100,
71 BandedHermitian = 0x00000200,
72 Banded = 0x00000400,
73 Triangular = 0x00000800,
74 QuasiTriangular = 0x00001000,
75 Hessenberg = 0x00002000,
76 Symmetric = 0x00004000,
77 Hermitian = 0x00008000,
78 SkewSymmetric = 0x00010000,
79 SkewHermitian = 0x00020000,
80 Full = 0x00040000
81 };
82 static const char* name(Structure);
83
84 typedef unsigned int StructureMask; // 32 bits
85 static const StructureMask AnyStructure = 0x0007ffffU; // see above
86 static const StructureMask UncommittedStructure = 0xffffffffU;
88
93 enum Position {
94 NoPosition = 0x0000,
95 Lower = 0x0001, // matrix is lower triangular (default)
96 Upper = 0x0002 // matrix is upper triangular
97 };
98 static const char* name(Position);
99
100 typedef unsigned short PositionMask; // 16 bits
101 static const PositionMask AnyPosition = 0x0003U; // see above
102 static const PositionMask UncommittedPosition = 0xffffU;
104
111 NoDiagValue = 0x0000,
112 StoredDiag = 0x0001, // could be anything (default)
113 ZeroDiag = 0x0002, // zero (e.g. for skew matrices)
114 UnitDiag = 0x0004 // unit (one) diagonal is used frequently by Lapack
115 };
116 static const char* name(DiagValue);
117
118 typedef unsigned short DiagValueMask; // 16 bits
119 static const DiagValueMask AnyDiagValue = 0x0003U;
120 static const DiagValueMask UncommittedDiagValue = 0xffffU;
122
124 if (structure == NoStructure)
125 structure = Full;
126 if (position == NoPosition)
127 position = Lower;
128 if (diagValue == NoDiagValue)
129 diagValue = StoredDiag;
130 return *this;
131 }
132
133 std::string name() const {
134 return std::string(name(getStructure()))
135 + "|" + std::string(name(getPosition()))
136 + "|" + std::string(name(getDiagValue()));
137 }
138
139 struct Mask {
140 Mask() {setToUncommitted();}
142 : structure(sm), position(pm), diagValue(dm) {}
144 { structure=UncommittedStructure; position=UncommittedPosition;
145 diagValue=UncommittedDiagValue; return *this; }
146 bool isUncommitted() const
147 { return structure==UncommittedStructure && position==UncommittedPosition
148 && diagValue==UncommittedDiagValue; }
149 bool isSatisfiedBy(Structure str, Position pos, DiagValue diag) const
150 { return ((StructureMask)str&structure)==(StructureMask)str
151 && ((PositionMask)pos&position)==(PositionMask)pos
152 && ((DiagValueMask)diag&diagValue)==(DiagValueMask)diag; }
153 bool isSatisfiedBy(const MatrixStructure& actual) const
154 { return isSatisfiedBy(actual.getStructure(), actual.getPosition(),
155 actual.getDiagValue()); }
156
160 };
161
162 MatrixStructure() {setToNone();}
163
166 MatrixStructure(Structure s, Position p=NoPosition, DiagValue d=NoDiagValue)
167 : structure(s), position(p), diagValue(d) {}
168
173 Mask mask() const;
174
175 Structure getStructure() const {return structure;}
176 Position getPosition() const {return position;}
177 DiagValue getDiagValue() const {return diagValue;}
178
179 MatrixStructure& setStructure(Structure s) {structure=s; return *this;}
180 MatrixStructure& setPosition (Position p) {position=p; return *this;}
181 MatrixStructure& setDiagValue(DiagValue d) {diagValue=d; return *this;}
182
184 { structure=s; position=p; diagValue=d; return *this; }
185
187 { structure=NoStructure; position=NoPosition;
188 diagValue=NoDiagValue; return *this; }
189
190private:
191 Structure structure:32;
192 Position position:16;
193 DiagValue diagValue:16;
194};
195
196
197// ------------------------------ MatrixStorage -------------------------------
202// ----------------------------------------------------------------------------
204public:
205 enum Packing {
206 NoPacking = 0x0000,
207 Full = 0x0001, // full storage layout
208 TriInFull = 0x0002, // a triangular piece of a full storage layout
209 TriPacked = 0x0004, // triangle packed into minimal storage, at performance cost
210 Banded = 0x0008, // a packed, banded storage format
211 Vector = 0x0010, // a possibly-strided or scattered vector
212 Scalar = 0x0020, // a single scalar is stored
213 Permutation = 0x0040 // a permuted identity matrix
214 };
215 static const char* name(Packing);
216 typedef unsigned short PackingMask;
217 static const PackingMask AllPacking = 0x007fU; // see above
218 static const PackingMask UncommittedPacking = 0xffffU;
219
221 NoPlacement = 0x0000,
222 Lower = 0x0001, // stored in lower triangle of full matrix
223 Upper = 0x0002, // stored in upper triangle of full matrix
224 };
225 static const char* name(Placement);
226 typedef unsigned short PlacementMask;
227 static const PlacementMask AllPlacement = 0x0003U; // see above
228 static const PlacementMask UncommittedPlacement = 0xffffU;
229
230 enum Order {
231 NoOrder = 0x0000,
232 ColumnOrder = 0x0001, // matrix is stored by columns
233 RowOrder = 0x0002, // matrix is stored by rows
234 };
235 static const char* name(Order);
236 typedef unsigned short OrderMask;
237 static const OrderMask AllOrder = 0x03U; // see above
238 static const OrderMask UncommittedOrder = 0xffU;
239
240 enum Diagonal {
241 NoDiag = 0x0000,
242 StoredDiag = 0x0001, // matrix diagonal is stored
243 AssumedDiag = 0x0002 // matrix diagonal is not stored but has known value
244 };
245 static const char* name(Diagonal);
246 typedef unsigned short DiagonalMask;
247 static const DiagonalMask AllDiagonal = 0x0003U; // see above
248 static const DiagonalMask UncommittedDiagonal = 0xffffU;
249
252 struct Mask {
254 : packing(UncommittedPacking), placement(UncommittedPlacement),
255 order(UncommittedOrder), diagonal(UncommittedDiagonal) {}
257 : packing(pkm), placement(plm), order(om), diagonal(dm) {}
259 { packing=UncommittedPacking; placement=UncommittedPlacement;
260 order=UncommittedOrder; diagonal=UncommittedDiagonal; return *this; }
261 bool isUncommitted() const
262 { return packing==UncommittedPacking && placement==UncommittedPlacement
263 && order==UncommittedOrder && diagonal==UncommittedDiagonal; }
264 bool isSatisfiedBy(Packing pack, Placement place, Order ord, Diagonal diag) const
265 { return ((PackingMask)pack & packing) == (PackingMask) pack
266 && ((PlacementMask)place & placement) == (PlacementMask)place
267 && ((OrderMask)ord & order) == (OrderMask) ord
268 && ((DiagonalMask)diag & diagonal) == (DiagonalMask) diag; }
269 bool isSatisfiedBy(const MatrixStorage& actual) const
270 { return isSatisfiedBy(actual.getPacking(), actual.getPlacement(),
271 actual.getOrder(), actual.getDiagonal());}
272
277 };
278
280 const MatrixOutline&);
281
282 std::string name() const {
283 return std::string(name(getPacking()))
284 + "|" + std::string(name(getPlacement()))
285 + "|" + std::string(name(getOrder()))
286 + "|" + std::string(name(getDiagonal()));
287 }
288
293 Mask mask() const {
294 Mask ms; // initially uncommitted
295 if (packing) ms.packing = (PackingMask)packing;
296 if (placement) ms.placement = (PlacementMask)placement;
297 if (order) ms.order = (OrderMask)order;
298 if (diagonal) ms.diagonal = (DiagonalMask)diagonal;
299 return ms;
300 }
301
304 : packing(NoPacking), placement(NoPlacement), order(NoOrder), diagonal(NoDiag) {}
305
309 MatrixStorage(Packing pk, Placement pl=NoPlacement, Order o=NoOrder, Diagonal d=NoDiag)
310 : packing(pk), placement(pl), order(o), diagonal(d) {}
311
315 : packing(pk), placement(NoPlacement), order(o), diagonal(StoredDiag) {}
316
320 if (packing==NoPacking)
321 packing = Full;
322 if (placement==NoPlacement)
323 placement = Lower;
324 if (order==NoOrder)
325 order = ColumnOrder;
326 if (diagonal==NoDiag)
327 diagonal = StoredDiag;
328 return *this;
329 }
330
333 { packing=NoPacking; placement=NoPlacement;
334 order=NoOrder; diagonal=NoDiag; return *this; }
335
336 MatrixStorage& setPacking(Packing p) {packing = p; return *this;}
337 MatrixStorage& setPlacement(Placement p) {placement = p; return *this;}
338 MatrixStorage& setOrder(Order o) {order = o; return *this;}
339 MatrixStorage& setDiagonal(Diagonal d) {diagonal = d; return *this;}
340
341 Packing getPacking() const {return packing;}
342 Placement getPlacement() const {return placement;}
343 Order getOrder() const {return order;}
344 Diagonal getDiagonal() const {return diagonal;}
345
346private:
347 Packing packing:16;
348 Placement placement:16;
349 Order order:16;
350 Diagonal diagonal:16;
351};
352
353
354// ------------------------------- MatrixOutline ------------------------------
375// ----------------------------------------------------------------------------
377public:
378 enum Outline {
379 NoOutline = 0x0000,
380 Scalar = 0x0001, // 1x1
381 Column = 0x0002, // mx1, m != 1
382 Row = 0x0004, // 1xn, n != 1
383 Square = 0x0008, // mxn, m == n
384 Wide = 0x0010, // mxn, m < n
385 Tall = 0x0020, // mxn, m > n
386 Rectangular = 0x0040 // mxn
387 };
388 static const char* name(Outline);
389
390 typedef unsigned short OutlineMask;
391 static const OutlineMask AnyOutline = 0x007fU; // see above
392 static const OutlineMask UncommittedOutline = 0xffffU;
393
394 struct Mask {
395 Mask() : outline(UncommittedOutline) {}
396 explicit Mask(OutlineMask mask) : outline(mask) {}
397 Mask& setToUncommitted() {outline=UncommittedOutline; return *this;}
398 bool isUncommitted() const {return outline==UncommittedOutline;}
399 bool isSatisfiedBy(const MatrixOutline& actual) const
400 { return ((OutlineMask)actual.outline & outline) == (OutlineMask)actual.outline; }
401
403 };
404
405 std::string name() const {return std::string(name(getOutline()));}
406
409 MatrixOutline() : outline(NoOutline) {}
410
412 MatrixOutline(Outline outline) : outline(outline) {}
413
415 MatrixOutline& setToNone() {outline=NoOutline; return *this;}
416
421
424 Mask mask() const {return Mask(calcMask(getOutline()));}
425
427 bool isSizeOK(int m, int n) const;
428
430 void getMinimumSize(int& m, int& n) const;
431
433 static MatrixOutline calcFromSize(int m, int n);
434
436 Outline getOutline() const {return outline;}
437
438private:
439 Outline outline:16;
440};
441
442
443
444// ---------------------------- MatrixCondition -------------------------------
453// ----------------------------------------------------------------------------
455public:
457 UnknownCondition = 0x0000,
458 Orthogonal = 0x0001, // implies well conditioned
459 PositiveDefinite = 0x0002, // implies well conditioned
460 WellConditioned = 0x0004, // implies full rank
461 FullRank = 0x0008, // but might have bad conditioning
462 Singular = 0x0010 // implies possible bad conditioning
463 };
464 static const char* name(Condition);
465
466 typedef unsigned short ConditionMask; // 16 bits in mask
467 static const ConditionMask AnyCondition = 0x001fU; // see above
468 static const ConditionMask UncommittedCondition = 0xffffU;
469
470 enum Diagonal {
471 UnknownDiagonal = 0x0000,
472 ZeroDiagonal = 0x0001,
473 OneDiagonal = 0x0002,
474 RealDiagonal = 0x0004,
475 ImaginaryDiagonal = 0x0008
476 };
477 static const char* name(Diagonal);
478
479 typedef unsigned short DiagonalMask; // 16 bits in mask
480 static const DiagonalMask AnyDiagonal = 0x000fU; // see above
481 static const DiagonalMask UncommittedDiagonal = 0xffffU;
482
484 struct Mask {
485 Mask() : condition(UncommittedCondition), diagonal(UncommittedDiagonal) {}
486 Mask(ConditionMask cmask, DiagonalMask dmask) : condition(cmask), diagonal(dmask) {}
488 { condition=UncommittedCondition; diagonal=UncommittedDiagonal; return *this;}
489 bool isUncommitted() const
490 { return condition==UncommittedCondition && diagonal==UncommittedDiagonal;}
491 bool isSatisfiedBy(const MatrixCondition& actual) const
492 { return ((ConditionMask)actual.condition & condition) == (ConditionMask)actual.condition
493 && ((DiagonalMask) actual.diagonal & diagonal) == (DiagonalMask)actual.diagonal; }
494
497 };
498
499 std::string name() const
500 { return std::string(name(getCondition())) + "|" + std::string(name(getDiagonal()));}
501
504 MatrixCondition() : condition(UnknownCondition), diagonal(UnknownDiagonal) {}
505
508 MatrixCondition(Condition cond, Diagonal diag=UnknownDiagonal)
509 : condition(cond), diagonal(diag) {}
510
512 MatrixCondition& setToNone() {condition=UnknownCondition; diagonal=UnknownDiagonal; return *this;}
513
520
527
530 Mask mask() const
531 { return Mask(calcMask(getCondition()), calcMask(getDiagonal())); }
532
533 Condition getCondition() const {return condition;}
534 Diagonal getDiagonal() const {return diagonal;}
535
536 MatrixCondition& setCondition(Condition c) {condition=c; return *this;}
537 MatrixCondition& setDiagonal (Diagonal d) {diagonal=d; return *this;}
538
539private:
540 Condition condition:16;
541 Diagonal diagonal:16;
542};
543
544
545
546// ------------------------------ MatrixCharacter -----------------------------
598public:
601 MatrixCharacter() : nr(0), nc(0), lband(0), uband(0) {}
602
603 // Some handy predefined MatrixCharacters.
604 class LapackFull;
605 class Vector;
606 class RowVector;
607
610 nr=nc=lband=uband=0;
611 structure.setToNone(); outline.setToNone();
612 storage.setToNone(); condition.setToNone();
613 return *this;
614 }
615
618 int nrow() const {return nr;}
619 int ncol() const {return nc;}
620 std::pair<int,int> getSize() const {return std::pair<int,int>(nrow(),ncol());}
621 ptrdiff_t nelt() const {return (ptrdiff_t)nrow() * (ptrdiff_t)ncol();}
622
623 int getLowerBandwidth() const {return lband;}
624 int getUpperBandwidth() const {return uband;}
625 std::pair<int,int> getBandwidth() const
626 { return std::pair<int,int>(getLowerBandwidth(), getUpperBandwidth()); }
627
628 const MatrixStructure& getStructure() const {return structure;}
629 const MatrixStorage& getStorage() const {return storage;}
630 const MatrixOutline& getOutline() const {return outline;}
631 const MatrixCondition& getCondition() const {return condition;}
632
633 MatrixStructure& updStructure() {return structure;}
634 MatrixStorage& updStorage() {return storage;}
635 MatrixOutline& updOutline() {return outline;}
636 MatrixCondition& updCondition() {return condition;}
637
638 MatrixCharacter& setStructure(const MatrixStructure& sa) {structure = sa; return *this;}
639 MatrixCharacter& setStorage (const MatrixStorage& sa) {storage = sa; return *this;}
640 MatrixCharacter& setOutline (const MatrixOutline& oa) {outline = oa; return *this;}
641 MatrixCharacter& setCondition(const MatrixCondition& ca) {condition = ca; return *this;}
642
643
646 { setSize(m,n); outline = MatrixOutline::calcFromSize(m,n); return *this; }
648 { setNumRows(m); outline = MatrixOutline::calcFromSize(m,ncol()); return *this; }
650 { setNumCols(n); outline = MatrixOutline::calcFromSize(nrow(),n); return *this; }
651
652 MatrixCharacter& setBandwidth(int lb, int ub) {
653 assert(lb>=0 && lb>=0);
654 lband = lb; uband = ub;
655 return *this;
656 }
658 assert(lb>=0);
659 lband = lb;
660 return *this;
661 }
663 assert(ub>=0);
664 uband = ub;
665 return *this;
666 }
667
668 class Mask; // defined below
669
670protected:
671 MatrixCharacter(int m, int n,
672 int lb, int ub,
673 MatrixStructure structure,
674 MatrixStorage storage,
675 MatrixCondition condition)
676 : nr(m), nc(n), lband(lb), uband(ub),
677 structure(structure), storage(storage),
678 outline(MatrixOutline::calcFromSize(m,n)),
679 condition(condition) {}
680
681
682 int nr,
684 int lband,
690
691private:
692 // These are private because they don't set the outline as well.
693 MatrixCharacter& setSize(int m, int n)
694 { assert(m>=0 && n>=0); nr = m; nc = n; return *this; }
695 MatrixCharacter& setNumRows(int m)
696 { assert(m>=0); nr = m; return *this; }
697 MatrixCharacter& setNumCols(int n)
698 { assert(n>=0); nc = n; return *this; }
699};
700
704operator<<(std::ostream& o, const MatrixCharacter&);
705
712public:
713 LapackFull(int m, int n)
714 : MatrixCharacter(m,n,0,0,
716 MatrixStorage(MatrixStorage::Full,MatrixStorage::ColumnOrder),
717 MatrixCondition()) {}
718};
719
725public:
726 Vector(int m)
727 : MatrixCharacter(m,1,0,0,
730 MatrixCondition()) {}
731};
732
738public:
744};
745
746// -------------------------- MatrixCharacter::Mask ---------------------------
749// ----------------------------------------------------------------------------
751public:
753
754 typedef unsigned int SizeMask;
755 static const SizeMask SizeUncommitted = 0xffffffffU;
756
759 bool isNumRowsLocked() const {return nr!=SizeUncommitted;}
760 bool isNumColsLocked() const {return nc!=SizeUncommitted;}
761
762 unsigned int getNumRowsMask() const {return nr;}
763 unsigned int getNumColsMask() const {return nc;}
764 unsigned int getLowerBandwidthMask() const {return lband;}
765 unsigned int getUpperBandwidthMask() const {return uband;}
766
767 int getDefaultNumRows() const {return isNumRowsLocked() ? nr : 0;}
768 int getDefaultNumCols() const {return isNumColsLocked() ? nc : 0;}
769
774
782
790
792 bool isSatisfiedBy(const MatrixCharacter& actual) const {
793 return isSizeOK(actual.nr, actual.nc)
794 && isBandwidthOK(actual.lband, actual.uband)
796 && storage.isSatisfiedBy(actual.getStorage())
797 && outline.isSatisfiedBy(actual.getOutline())
799 }
800
802 bool isSizeOK(int m, int n) const
803 { return ((SizeMask)m & nr) == (SizeMask)m
804 && ((SizeMask)n & nc) == (SizeMask)n; }
805
808 bool isBandwidthOK(int lower, int upper) const
809 { return ((SizeMask)lower & lband) == (SizeMask)lower
810 && ((SizeMask)upper & uband) == (SizeMask)upper; }
811
820
821friend class MatrixCommitment;
822};
823
824// ----------------------------- MatrixCommitment -----------------------------
825
830
831// ----------------------------------------------------------------------------
833public:
834 MatrixCommitment() {} // set commitments to "none" and masks to "uncommitted"
835
840
841 class Vector;
842 class RowVector;
843 class Triangular;
844 class Symmetric;
845 class Hermitian;
846 class SkewSymmetric;
847 class SkewHermitian;
848
850 { commitNumRows(m); commitNumCols(n); return *this; }
852 { SimTK_SIZECHECK_NONNEG(m, "MatrixCommitment::commitNumRows()");
853 masks.nr = m; return *this; }
855 { SimTK_SIZECHECK_NONNEG(n, "MatrixCommitment::commitNumCols()");
856 masks.nc = n; return *this; }
857
859 { commitLowerBandwidth(lb); commitUpperBandwidth(ub); return *this;}
861 { SimTK_SIZECHECK_NONNEG(lb, "MatrixCommitment::commitLowerBandwidth()");
862 masks.lband = lb; return *this; }
864 { SimTK_SIZECHECK_NONNEG(ub, "MatrixCommitment::commitUpperBandwidth()");
865 masks.uband = ub; return *this; }
866
868 { structure=s; masks.structure=s.mask(); return *this; }
870 { storage=s; masks.storage =s.mask(); return *this; }
872 { outline=o; masks.outline =o.mask(); return *this; }
874 { condition=c; masks.condition=c.mask(); return *this; }
875
886 MatrixCharacter calcDefaultCharacter(int minNumRows, int minNumCols) const;
887
889 const MatrixStructure& getStructureCommitment() const {return structure;}
890 const MatrixStorage& getStorageCommitment() const {return storage;}
891 const MatrixOutline& getOutlineCommitment() const {return outline;}
892 const MatrixCondition& getConditionCommitment() const {return condition;}
893
895 const MatrixStructure::Mask& getStructureMask() const {return masks.structure;}
896 const MatrixStorage::Mask& getStorageMask() const {return masks.storage;}
897 const MatrixOutline::Mask& getOutlineMask() const {return masks.outline;}
898 const MatrixCondition::Mask& getConditionMask() const {return masks.condition;}
899
904
905 int getDefaultNumRows() const {return masks.getDefaultNumRows();}
906 int getDefaultNumCols() const {return masks.getDefaultNumCols();}
907
908 bool isSizeOK(int m, int n) const {return masks.isSizeOK(m,n);}
909 bool isSizeOK(const std::pair<int,int>& mn) const
910 { return isSizeOK(mn.first, mn.second); }
911
912 bool isBandwidthOK(int lower, int upper) const {return masks.isBandwidthOK(lower,upper);}
913
914 bool isSatisfiedBy(const MatrixCharacter& actual) const
915 { return masks.isSatisfiedBy(actual); }
916 bool isStructureOK(const MatrixStructure& s) const
917 { return getStructureMask().isSatisfiedBy(s); }
918 bool isStorageOK(const MatrixStorage& s) const
919 { return getStorageMask().isSatisfiedBy(s); }
920 bool isOutlineOK(const MatrixOutline& o) const
921 { return getOutlineMask().isSatisfiedBy(o); }
922 bool isConditionOK(const MatrixCondition& c) const
923 { return getConditionMask().isSatisfiedBy(c); }
924
925 bool isResizeable() const {return masks.isResizeable();}
926 bool isFullyResizeable() const {return masks.isFullyResizeable();;}
927 bool isNumRowsLocked() const {return masks.isNumRowsLocked();}
928 bool isNumColsLocked() const {return masks.isNumColsLocked();}
929
931 { return !getStructureMask().isUncommitted(); }
932 bool isStorageCommitted() const
933 { return !getStorageMask().isUncommitted();}
934 bool isOutlineCommitted() const
935 { return !getOutlineMask().isUncommitted(); }
937 { return !getConditionMask().isUncommitted();}
938
940 void clear() {
941 structure.setToNone();
942 storage.setToNone();
943 outline.setToNone();
944 condition.setToNone();
945 masks.setToUncommitted();
946 }
947
948protected:
950 const MatrixStorage& storage,
951 const MatrixOutline& outline,
952 const MatrixCondition& condition)
953 : structure(structure), storage(storage),
954 outline(outline), condition(condition),
955 masks() // set to all 1's
956 {
957 if (outline.getOutline()==MatrixOutline::Scalar) commitSize(1,1);
958 else if (outline.getOutline()==MatrixOutline::Column) commitNumCols(1);
959 else if (outline.getOutline()==MatrixOutline::Row) commitNumRows(1);
960
961 masks.structure = structure.mask();
962 masks.storage = storage.mask();
963 masks.outline = outline.mask();
964 masks.condition = condition.mask();
965 }
966
973
977};
978
979
982public:
986 ( MatrixStructure(MatrixStructure::Matrix1d),
990 {
991 }
993 explicit Vector(int m)
995 ( MatrixStructure(MatrixStructure::Matrix1d),
999 {
1000 commitNumRows(m);
1001 }
1002};
1003
1006public:
1017 explicit RowVector(int n)
1019 ( MatrixStructure(MatrixStructure::Matrix1d),
1020 MatrixStorage(),
1023 {
1024 commitNumCols(n);
1025 }
1026};
1027
1037
1048
1053public:
1057 MatrixStorage(),
1058 MatrixOutline(),
1059 MatrixCondition().setDiagonal(MatrixCondition::RealDiagonal))
1060 {
1061 }
1062};
1063
1068public:
1072 MatrixStorage(),
1073 MatrixOutline(),
1074 MatrixCondition().setDiagonal(MatrixCondition::ZeroDiagonal))
1075 {
1076 }
1077};
1078
1083public:
1087 MatrixStorage(),
1088 MatrixOutline(),
1089 MatrixCondition().setDiagonal(MatrixCondition::ImaginaryDiagonal))
1090 {
1091 }
1092};
1093
1097operator<<(std::ostream& o, const MatrixCommitment&);
1098
1099} //namespace SimTK
1100
1101#endif // SimTK_SIMMATRIX_MATRIX_CHARACTERISTICS_H_
#define SimTK_SIZECHECK_NONNEG(sz, where)
Definition ExceptionMacros.h:147
This is a user-includable header which includes everything needed to make use of SimMatrix Scalar cod...
#define SimTK_SimTKCOMMON_EXPORT
Definition SimTKcommon/include/SimTKcommon/internal/common.h:224
Predefined MatrixCharacter for an ordinary Lapack-style full matrix of a particular dimension m x n (...
Definition MatrixCharacteristics.h:711
LapackFull(int m, int n)
Definition MatrixCharacteristics.h:713
This class collects masks of each characteristic type for representing sets of accceptable characteri...
Definition MatrixCharacteristics.h:750
Mask & setToUncommitted()
Set all bits to one ("Uncommitted").
Definition MatrixCharacteristics.h:776
int getDefaultNumRows() const
Definition MatrixCharacteristics.h:767
SizeMask nr
number of rows
Definition MatrixCharacteristics.h:812
SizeMask lband
lower bandwidth, if banded
Definition MatrixCharacteristics.h:814
int getDefaultUpperBandwidth() const
Definition MatrixCharacteristics.h:773
bool isBandwidthOK(int lower, int upper) const
Check whether an actual bandwidth satisfies the bandwidth commitment.
Definition MatrixCharacteristics.h:808
MatrixCondition::Mask condition
Definition MatrixCharacteristics.h:819
SizeMask nc
number of columns
Definition MatrixCharacteristics.h:813
int getDefaultLowerBandwidth() const
Definition MatrixCharacteristics.h:772
bool isResizeable() const
Definition MatrixCharacteristics.h:757
Mask()
Definition MatrixCharacteristics.h:752
unsigned int getLowerBandwidthMask() const
Definition MatrixCharacteristics.h:764
MatrixStructure::Mask structure
Definition MatrixCharacteristics.h:816
SizeMask uband
upper bandwidth, if banded
Definition MatrixCharacteristics.h:815
unsigned int getNumRowsMask() const
Definition MatrixCharacteristics.h:762
MatrixStorage::Mask storage
Definition MatrixCharacteristics.h:817
unsigned int SizeMask
Definition MatrixCharacteristics.h:754
bool isNumColsLocked() const
Definition MatrixCharacteristics.h:760
bool isSatisfiedBy(const MatrixCharacter &actual) const
Check whether an actual matrix character satisfies this matrix commitment.
Definition MatrixCharacteristics.h:792
static const SizeMask SizeUncommitted
Definition MatrixCharacteristics.h:755
MatrixOutline::Mask outline
Definition MatrixCharacteristics.h:818
bool isNumRowsLocked() const
Definition MatrixCharacteristics.h:759
unsigned int getUpperBandwidthMask() const
Definition MatrixCharacteristics.h:765
bool isUpperBandwidthLocked() const
Definition MatrixCharacteristics.h:771
bool isUncommitted() const
Return if all fields are set to "Uncommitted" (all bits are one).
Definition MatrixCharacteristics.h:784
bool isLowerBandwidthLocked() const
Definition MatrixCharacteristics.h:770
int getDefaultNumCols() const
Definition MatrixCharacteristics.h:768
bool isSizeOK(int m, int n) const
Check whether an actual size satisfies the size commitment.
Definition MatrixCharacteristics.h:802
unsigned int getNumColsMask() const
Definition MatrixCharacteristics.h:763
bool isFullyResizeable() const
Definition MatrixCharacteristics.h:758
Predefined MatrixCharacter for an ordinary row vector of a particular size.
Definition MatrixCharacteristics.h:737
RowVector(int n)
Definition MatrixCharacteristics.h:739
Predefined MatrixCharacter for an ordinary column vector of a particular size.
Definition MatrixCharacteristics.h:724
Vector(int m)
Definition MatrixCharacteristics.h:726
A MatrixCharacter is a set containing a value for each of the matrix characteristics except element t...
Definition MatrixCharacteristics.h:597
int nrow() const
These are dimensions of the logical matrix and have nothing to do with how much storage may be used t...
Definition MatrixCharacteristics.h:618
int ncol() const
Definition MatrixCharacteristics.h:619
MatrixStorage storage
Definition MatrixCharacteristics.h:687
ptrdiff_t nelt() const
Definition MatrixCharacteristics.h:621
MatrixCharacter & setActualSize(int m, int n)
Set the actual size and update the outline to match.
Definition MatrixCharacteristics.h:645
int nc
actual number of columns
Definition MatrixCharacteristics.h:683
MatrixCharacter & setActualNumRows(int m)
Definition MatrixCharacteristics.h:647
const MatrixStructure & getStructure() const
Definition MatrixCharacteristics.h:628
MatrixCharacter(int m, int n, int lb, int ub, MatrixStructure structure, MatrixStorage storage, MatrixCondition condition)
Definition MatrixCharacteristics.h:671
int lband
actual lower bandwidth, if banded
Definition MatrixCharacteristics.h:684
std::pair< int, int > getSize() const
Definition MatrixCharacteristics.h:620
int uband
actual upper bandwidth, if banded
Definition MatrixCharacteristics.h:685
MatrixCondition & updCondition()
Definition MatrixCharacteristics.h:636
int getLowerBandwidth() const
Definition MatrixCharacteristics.h:623
MatrixOutline & updOutline()
Definition MatrixCharacteristics.h:635
MatrixCharacter & setStructure(const MatrixStructure &sa)
Definition MatrixCharacteristics.h:638
MatrixCharacter & setStorage(const MatrixStorage &sa)
Definition MatrixCharacteristics.h:639
const MatrixCondition & getCondition() const
Definition MatrixCharacteristics.h:631
MatrixCharacter & setLowerBandwidth(int lb)
Definition MatrixCharacteristics.h:657
MatrixCharacter & setBandwidth(int lb, int ub)
Definition MatrixCharacteristics.h:652
MatrixCharacter & setOutline(const MatrixOutline &oa)
Definition MatrixCharacteristics.h:640
MatrixCondition condition
Definition MatrixCharacteristics.h:689
MatrixCharacter()
Default constructor sets lengths to zero and the other characteristics to "none specified".
Definition MatrixCharacteristics.h:601
MatrixStructure structure
Definition MatrixCharacteristics.h:686
MatrixCharacter & setToNone()
Restore this MatrixCharacter to its default-constructed state of "none".
Definition MatrixCharacteristics.h:609
MatrixCharacter & setCondition(const MatrixCondition &ca)
Definition MatrixCharacteristics.h:641
MatrixOutline outline
Definition MatrixCharacteristics.h:688
const MatrixOutline & getOutline() const
Definition MatrixCharacteristics.h:630
MatrixCharacter & setActualNumCols(int n)
Definition MatrixCharacteristics.h:649
int nr
actual number of rows
Definition MatrixCharacteristics.h:682
MatrixStorage & updStorage()
Definition MatrixCharacteristics.h:634
MatrixCharacter & setUpperBandwidth(int ub)
Definition MatrixCharacteristics.h:662
int getUpperBandwidth() const
Definition MatrixCharacteristics.h:624
std::pair< int, int > getBandwidth() const
Definition MatrixCharacteristics.h:625
const MatrixStorage & getStorage() const
Definition MatrixCharacteristics.h:629
MatrixStructure & updStructure()
Definition MatrixCharacteristics.h:633
This is the default commitment for a Hermitian (not symmetric) matrix.
Definition MatrixCharacteristics.h:1052
Hermitian()
Definition MatrixCharacteristics.h:1054
This is the default commitment for a row vector.
Definition MatrixCharacteristics.h:1005
RowVector(int n)
Commit to a row vector of a particular length.
Definition MatrixCharacteristics.h:1017
RowVector()
Commit to a resizeable row vector.
Definition MatrixCharacteristics.h:1008
This is the default commitment for a skew Hermitian (not skew symmetric) matrix.
Definition MatrixCharacteristics.h:1082
SkewHermitian()
Definition MatrixCharacteristics.h:1084
This is the default commitment for skew symmetric (not skew Hermitian) matrix.
Definition MatrixCharacteristics.h:1067
SkewSymmetric()
Definition MatrixCharacteristics.h:1069
This is the default commitment for a symmetric (not Hermitian) matrix.
Definition MatrixCharacteristics.h:1040
Symmetric()
Definition MatrixCharacteristics.h:1042
This is the default commitment for a triangular matrix.
Definition MatrixCharacteristics.h:1029
Triangular()
Definition MatrixCharacteristics.h:1031
This is the default commitment for a column vector.
Definition MatrixCharacteristics.h:981
Vector(int m)
Commit to a column vector of a particular length.
Definition MatrixCharacteristics.h:993
Vector()
Commit to a resizeable column vector.
Definition MatrixCharacteristics.h:984
A MatrixCommitment provides a set of acceptable matrix characteristics.
Definition MatrixCharacteristics.h:832
const MatrixStorage::Mask & getStorageMask() const
Definition MatrixCharacteristics.h:896
MatrixCharacter::Mask::SizeMask getNumColsMask() const
Definition MatrixCharacteristics.h:901
bool isOutlineOK(const MatrixOutline &o) const
Definition MatrixCharacteristics.h:920
const MatrixStructure::Mask & getStructureMask() const
These report the masks of acceptable values generated from the commitment.
Definition MatrixCharacteristics.h:895
MatrixCondition condition
Definition MatrixCharacteristics.h:972
MatrixCommitment & commitOutline(const MatrixOutline &o)
Definition MatrixCharacteristics.h:871
MatrixCommitment()
Definition MatrixCharacteristics.h:834
MatrixCharacter::Mask::SizeMask getNumRowsMask() const
Definition MatrixCharacteristics.h:900
MatrixCommitment & commitUpperBandwidth(int ub)
Definition MatrixCharacteristics.h:863
bool isNumColsLocked() const
Definition MatrixCharacteristics.h:928
MatrixCommitment & commitStorage(const MatrixStorage &s)
Definition MatrixCharacteristics.h:869
const MatrixOutline & getOutlineCommitment() const
Definition MatrixCharacteristics.h:891
MatrixStorage storage
Definition MatrixCharacteristics.h:970
const MatrixCondition::Mask & getConditionMask() const
Definition MatrixCharacteristics.h:898
bool isStructureCommitted() const
Definition MatrixCharacteristics.h:930
MatrixCharacter::Mask masks
These are the bitmasks of acceptable characteristics which would satisfy the above-specified commitme...
Definition MatrixCharacteristics.h:976
bool isSizeOK(int m, int n) const
Definition MatrixCharacteristics.h:908
MatrixCommitment & commitCondition(const MatrixCondition &c)
Definition MatrixCharacteristics.h:873
MatrixCommitment & commitNumCols(int n)
Definition MatrixCharacteristics.h:854
bool isConditionCommitted() const
Definition MatrixCharacteristics.h:936
bool isOutlineCommitted() const
Definition MatrixCharacteristics.h:934
MatrixCommitment & commitSize(int m, int n)
Definition MatrixCharacteristics.h:849
bool isBandwidthOK(int lower, int upper) const
Definition MatrixCharacteristics.h:912
bool isStructureOK(const MatrixStructure &s) const
Definition MatrixCharacteristics.h:916
MatrixCommitment(const MatrixStructure &str)
This is an implicit conversion from a MatrixStructure specification to a MatrixCommitment with storag...
Definition MatrixCharacteristics.h:838
bool isResizeable() const
Definition MatrixCharacteristics.h:925
bool isSizeOK(const std::pair< int, int > &mn) const
Definition MatrixCharacteristics.h:909
MatrixCommitment & commitStructure(const MatrixStructure &s)
Definition MatrixCharacteristics.h:867
MatrixOutline outline
Definition MatrixCharacteristics.h:971
const MatrixCondition & getConditionCommitment() const
Definition MatrixCharacteristics.h:892
int getDefaultNumRows() const
Definition MatrixCharacteristics.h:905
const MatrixStructure & getStructureCommitment() const
These report the commitment as it was specified.
Definition MatrixCharacteristics.h:889
MatrixCommitment & commitLowerBandwidth(int lb)
Definition MatrixCharacteristics.h:860
bool isStorageCommitted() const
Definition MatrixCharacteristics.h:932
MatrixCharacter calcDefaultCharacter(int minNumRows, int minNumCols) const
For any handle commitment, we can calculate a "best character" for an allocation that satisfies the c...
int getDefaultNumCols() const
Definition MatrixCharacteristics.h:906
bool isStorageOK(const MatrixStorage &s) const
Definition MatrixCharacteristics.h:918
const MatrixOutline::Mask & getOutlineMask() const
Definition MatrixCharacteristics.h:897
MatrixCharacter::Mask::SizeMask getLowerBandwidthMask() const
Definition MatrixCharacteristics.h:902
bool isConditionOK(const MatrixCondition &c) const
Definition MatrixCharacteristics.h:922
void clear()
Set commitment s to "none" and masks to "uncommitted" for all characteristics.
Definition MatrixCharacteristics.h:940
MatrixCommitment & commitBandwidth(int lb, int ub)
Definition MatrixCharacteristics.h:858
MatrixCommitment & commitNumRows(int m)
Definition MatrixCharacteristics.h:851
MatrixStructure structure
These are the commitments as specified.
Definition MatrixCharacteristics.h:969
const MatrixStorage & getStorageCommitment() const
Definition MatrixCharacteristics.h:890
bool isFullyResizeable() const
Definition MatrixCharacteristics.h:926
bool isSatisfiedBy(const MatrixCharacter &actual) const
Definition MatrixCharacteristics.h:914
bool isNumRowsLocked() const
Definition MatrixCharacteristics.h:927
MatrixCommitment(const MatrixStructure &structure, const MatrixStorage &storage, const MatrixOutline &outline, const MatrixCondition &condition)
Definition MatrixCharacteristics.h:949
MatrixCharacter::Mask::SizeMask getUpperBandwidthMask() const
Definition MatrixCharacteristics.h:903
Matrix "condition" is a statement about the numerical characteristics of a Matrix.
Definition MatrixCharacteristics.h:454
unsigned short DiagonalMask
Definition MatrixCharacteristics.h:479
Condition
Definition MatrixCharacteristics.h:456
Condition getCondition() const
Definition MatrixCharacteristics.h:533
MatrixCondition(Condition cond, Diagonal diag=UnknownDiagonal)
This is an implicit conversion from the Condition enum to a MatrixCondition object.
Definition MatrixCharacteristics.h:508
static const char * name(Condition)
Diagonal
Definition MatrixCharacteristics.h:470
static ConditionMask calcMask(Condition)
Given a particular Condition provided as a commitment, calculate the mask of all Condition values tha...
MatrixCondition & setDiagonal(Diagonal d)
Definition MatrixCharacteristics.h:537
MatrixCondition()
The default constructor sets the condition to Unknown, which is typically where it remains.
Definition MatrixCharacteristics.h:504
MatrixCondition & setToNone()
Restore to default-constructed state of "none".
Definition MatrixCharacteristics.h:512
MatrixCondition & setCondition(Condition c)
Definition MatrixCharacteristics.h:536
static const char * name(Diagonal)
std::string name() const
Definition MatrixCharacteristics.h:499
Diagonal getDiagonal() const
Definition MatrixCharacteristics.h:534
Mask mask() const
Return the commitment mask corresponding to use of "this" condition as a commitment.
Definition MatrixCharacteristics.h:530
unsigned short ConditionMask
Definition MatrixCharacteristics.h:466
static DiagonalMask calcMask(Diagonal)
Given a particular Diagonal condition provided as a commitment, calculate the mask of all Diagonal co...
Matrix "outline" refers to the characteristic relationship between the number of rows and columns of ...
Definition MatrixCharacteristics.h:376
static OutlineMask calcMask(Outline)
Compute a mask of acceptable Outline values given a particular value specified as a commitment.
static const char * name(Outline)
Outline getOutline() const
Return the outline value stored in this MatrixOutline object.
Definition MatrixCharacteristics.h:436
MatrixOutline(Outline outline)
This is an implicit conversion from the Outline enum to a MatrixOutline object.
Definition MatrixCharacteristics.h:412
Mask mask() const
When "this" outline is used as a commitment, it represents a mask of acceptable outlines.
Definition MatrixCharacteristics.h:424
MatrixOutline()
Default constructor produces an object containing no outline specification.
Definition MatrixCharacteristics.h:409
Outline
Definition MatrixCharacteristics.h:378
std::string name() const
Definition MatrixCharacteristics.h:405
static MatrixOutline calcFromSize(int m, int n)
Determine the outline from given actual dimensions.
MatrixOutline & setToNone()
Set the outline back to its default-constructed value of "none".
Definition MatrixCharacteristics.h:415
void getMinimumSize(int &m, int &n) const
Return the minimum shape that will satisfy this outline.
bool isSizeOK(int m, int n) const
Determine if the proposed shape satisfies this outline.
unsigned short OutlineMask
Definition MatrixCharacteristics.h:390
Matrix "storage" refers to the physical layout of data in the computer's memory.
Definition MatrixCharacteristics.h:203
static const char * name(Packing)
MatrixStorage & setPacking(Packing p)
Definition MatrixCharacteristics.h:336
MatrixStorage(Packing pk, Order o)
This constructor is for the common case of just packing and order, with no particular placement and a...
Definition MatrixCharacteristics.h:314
static const char * name(Order)
static const char * name(Placement)
unsigned short OrderMask
Definition MatrixCharacteristics.h:236
Diagonal getDiagonal() const
Definition MatrixCharacteristics.h:344
MatrixStorage & setPlacement(Placement p)
Definition MatrixCharacteristics.h:337
unsigned short DiagonalMask
Definition MatrixCharacteristics.h:246
MatrixStorage & setOrder(Order o)
Definition MatrixCharacteristics.h:338
static MatrixStorage calcDefaultStorage(const MatrixStructure &, const MatrixOutline &)
std::string name() const
Definition MatrixCharacteristics.h:282
Diagonal
Definition MatrixCharacteristics.h:240
Placement getPlacement() const
Definition MatrixCharacteristics.h:342
Packing
Definition MatrixCharacteristics.h:205
unsigned short PlacementMask
Definition MatrixCharacteristics.h:226
MatrixStorage & setMissingAttributes()
Assuming this is an actual matrix description, set any unspecified attributes to appropriate defaults...
Definition MatrixCharacteristics.h:319
MatrixStorage(Packing pk, Placement pl=NoPlacement, Order o=NoOrder, Diagonal d=NoDiag)
This constructor is also an implicit conversion from the Packing enum to a MatrixStorage object which...
Definition MatrixCharacteristics.h:309
Order getOrder() const
Definition MatrixCharacteristics.h:343
unsigned short PackingMask
Definition MatrixCharacteristics.h:216
Placement
Definition MatrixCharacteristics.h:220
Mask mask() const
Calculate the commitment mask associated with specifying "this" set of storage attributes as a commit...
Definition MatrixCharacteristics.h:293
static const char * name(Diagonal)
MatrixStorage & setDiagonal(Diagonal d)
Definition MatrixCharacteristics.h:339
Packing getPacking() const
Definition MatrixCharacteristics.h:341
Order
Definition MatrixCharacteristics.h:230
MatrixStorage()
Default constructor leaves all fields unspecified.
Definition MatrixCharacteristics.h:303
MatrixStorage & setToNone()
Restore this object to its default-constructed state of "none".
Definition MatrixCharacteristics.h:332
Matrix "structure" refers to an inherent mathematical (or at least algorithmic) characteristic of the...
Definition MatrixCharacteristics.h:58
Structure getStructure() const
Definition MatrixCharacteristics.h:175
static StructureMask calcStructureMask(Structure)
Structure
Definition MatrixCharacteristics.h:60
Position
For triangular matrices, we have to know which triangle we're talking about.
Definition MatrixCharacteristics.h:93
DiagValue getDiagValue() const
Definition MatrixCharacteristics.h:177
static const char * name(DiagValue)
Position getPosition() const
Definition MatrixCharacteristics.h:176
static const char * name(Position)
MatrixStructure()
Definition MatrixCharacteristics.h:162
MatrixStructure & setMissingAttributes()
Definition MatrixCharacteristics.h:123
MatrixStructure & setToNone()
Definition MatrixCharacteristics.h:186
MatrixStructure & setPosition(Position p)
Definition MatrixCharacteristics.h:180
static DiagValueMask calcDiagValueMask(Structure)
std::string name() const
Definition MatrixCharacteristics.h:133
static const char * name(Structure)
MatrixStructure & set(Structure s, Position p, DiagValue d)
Definition MatrixCharacteristics.h:183
static PositionMask calcPositionMask(Structure)
DiagValue
For triangular, symmetric, and hermitian matrices the diagonal elements may have a single,...
Definition MatrixCharacteristics.h:110
MatrixStructure & setStructure(Structure s)
Definition MatrixCharacteristics.h:179
MatrixStructure & setDiagValue(DiagValue d)
Definition MatrixCharacteristics.h:181
unsigned short DiagValueMask
Definition MatrixCharacteristics.h:118
MatrixStructure(Structure s, Position p=NoPosition, DiagValue d=NoDiagValue)
This constructor is also an implicit conversion from the Structure enum to a MatrixStructure object w...
Definition MatrixCharacteristics.h:166
unsigned short PositionMask
Definition MatrixCharacteristics.h:100
Mask mask() const
Given a Structure commitment, which more-restrictive Structures will still satisfy this commitment?...
unsigned int StructureMask
Definition MatrixCharacteristics.h:84
Represents a variable size row vector; much less common than the column vector type Vector_.
Definition RowVector_.h:52
This is a fixed-length row vector designed for no-overhead inline computation.
Definition Row.h:132
const Real Zero
Real(0)
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition Assembler.h:37
std::ostream & operator<<(std::ostream &o, const ContactForce &f)
Definition CompliantContactSubsystem.h:387
Use this class to represent a set of acceptable Condition values.
Definition MatrixCharacteristics.h:484
Mask()
Definition MatrixCharacteristics.h:485
ConditionMask condition
Definition MatrixCharacteristics.h:495
Mask & setToUncommitted()
Definition MatrixCharacteristics.h:487
bool isUncommitted() const
Definition MatrixCharacteristics.h:489
bool isSatisfiedBy(const MatrixCondition &actual) const
Definition MatrixCharacteristics.h:491
Mask(ConditionMask cmask, DiagonalMask dmask)
Definition MatrixCharacteristics.h:486
DiagonalMask diagonal
Definition MatrixCharacteristics.h:496
Definition MatrixCharacteristics.h:394
bool isUncommitted() const
Definition MatrixCharacteristics.h:398
Mask & setToUncommitted()
Definition MatrixCharacteristics.h:397
Mask(OutlineMask mask)
Definition MatrixCharacteristics.h:396
bool isSatisfiedBy(const MatrixOutline &actual) const
Definition MatrixCharacteristics.h:399
OutlineMask outline
Definition MatrixCharacteristics.h:402
Mask()
Definition MatrixCharacteristics.h:395
Use this class to represent sets of acceptable values for each of the storage attributes (packing,...
Definition MatrixCharacteristics.h:252
PackingMask packing
Definition MatrixCharacteristics.h:273
PlacementMask placement
Definition MatrixCharacteristics.h:274
DiagonalMask diagonal
Definition MatrixCharacteristics.h:276
bool isSatisfiedBy(Packing pack, Placement place, Order ord, Diagonal diag) const
Definition MatrixCharacteristics.h:264
bool isUncommitted() const
Definition MatrixCharacteristics.h:261
Mask & setToUncommitted()
Definition MatrixCharacteristics.h:258
OrderMask order
Definition MatrixCharacteristics.h:275
Mask()
Definition MatrixCharacteristics.h:253
bool isSatisfiedBy(const MatrixStorage &actual) const
Definition MatrixCharacteristics.h:269
Mask(PackingMask pkm, PlacementMask plm, OrderMask om, DiagonalMask dm)
Definition MatrixCharacteristics.h:256
Definition MatrixCharacteristics.h:139
Mask(StructureMask sm, PositionMask pm, DiagValueMask dm)
Definition MatrixCharacteristics.h:141
bool isSatisfiedBy(const MatrixStructure &actual) const
Definition MatrixCharacteristics.h:153
StructureMask structure
Definition MatrixCharacteristics.h:157
bool isSatisfiedBy(Structure str, Position pos, DiagValue diag) const
Definition MatrixCharacteristics.h:149
PositionMask position
Definition MatrixCharacteristics.h:158
Mask()
Definition MatrixCharacteristics.h:140
bool isUncommitted() const
Definition MatrixCharacteristics.h:146
Mask & setToUncommitted()
Definition MatrixCharacteristics.h:143
DiagValueMask diagValue
Definition MatrixCharacteristics.h:159