SheafSystem  0.0.0.0
e2.cc
Go to the documentation of this file.
1 
2 //
3 // Copyright (c) 2014 Limit Point Systems, Inc.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 
20 
21 #include "SheafSystem/e2.impl.h"
22 
23 #include "SheafSystem/abstract_poset_member.impl.h"
24 #include "SheafSystem/assert_contract.h"
25 #include "SheafSystem/at0.h"
26 #include "SheafSystem/at0_space.h"
27 #include "SheafSystem/at1_space.h"
28 #include "SheafSystem/at2_e2.h"
29 #include "SheafSystem/fiber_bundles_namespace.h"
30 #include "SheafSystem/atp_space.h"
31 #include "SheafSystem/schema_poset_member.h"
32 #include "SheafSystem/st2_e2.h"
33 #include "SheafSystem/st4_e2.h"
34 #include "SheafSystem/stp_space.h"
35 #include "SheafSystem/t2_e2.h"
36 #include "SheafSystem/t4_e2.h"
37 #include "SheafSystem/wsv_block.h"
38 
39 
40 using namespace std;
41 using namespace fiber_bundle; // Workaround for MS C++ bug.
42 
43 
44 //==============================================================================
45 // CLASS E2_LITE
46 //==============================================================================
47 
48 
49 //==============================================================================
50 // EUCLIDEAN VECTOR ALGEBRA (E2) FACET OF CLASS E2_LITE
51 //==============================================================================
52 
53 // PUBLIC MEMBER FUNCTIONS
54 
57 {
58 
59  // Preconditions:
60 
61  // Body:
62 
63  // Postconditions:
64 
65  ensure(invariant());
66 
67  // Exit:
68 }
69 
71 e2_lite(const e2_lite& xother)
72 {
73  // Preconditions:
74 
75  // Body:
76 
77  *this = xother;
78 
79  // Postconditions:
80 
81  ensure(invariant());
82 
83  // Exit:
84 }
85 
88 operator=(const e2_lite& xother)
89 {
90 
91  // Preconditions:
92 
93  // Body:
94 
95  if(this == &xother)
96  return *this;
97 
98  _row_dofs = xother._row_dofs;
99 
100  // Postconditions:
101 
102  ensure(invariant());
103  ensure(unexecutable(*this == xother));
104 
105  // Exit:
106 
107  return *this;
108 }
109 
112 {
113  // Preconditions:
114 
115  // Body:
116 
117  // Postconditions:
118 
119  // Exit:
120 }
121 
123 e2_lite(const row_dofs_type& xrow_dofs)
124 {
125  // Preconditions:
126 
127  // Body:
128 
129  *this = xrow_dofs;
130 
131  // Postconditions:
132 
133  ensure(invariant());
134 
135  // Exit:
136 }
137 
140 operator=(const row_dofs_type& xrow_dofs)
141 {
142  // Preconditions:
143 
144  // Body:
145 
146  _row_dofs = xrow_dofs;
147 
148  // Postconditions:
149 
150  ensure(invariant());
151  ensure(unexecutable(row_dofs() == xrow_dofs));
152  //ensure_for_all(i, 0, d(), component(i) == xrow_dofs[i]);
153 
154  // Exit:
155 
156  return *this;
157 
158 }
159 
161 e2_lite(const value_type& x0, const value_type& x1)
162 {
163  // Preconditions:
164 
165  // Body:
166 
167  put_components(x0, x1);
168 
169  // Postconditions:
170 
171  ensure(invariant());
172  ensure(isunordered_or_equals(component(0), x0));
173  ensure(isunordered_or_equals(component(1), x1));
174 
175  // Exit:
176 }
177 
178 void
181  const value_type& y_comp)
182 {
183  // Preconditions:
184 
185  // Body:
186 
187  put_component(0, x_comp);
188  put_component(1, y_comp);
189 
190  // Postconditions:
191 
192  ensure(invariant());
193  ensure(isunordered_or_equals(component(0), x_comp));
194  ensure(isunordered_or_equals(component(1), y_comp));
195 
196  // Exit:
197 }
198 
199 fiber_bundle::e2_lite::
201 {
202  // Preconditions:
203 
204  // Body:
205 
206  row_dofs_type& result = _row_dofs;
207 
208  // Postconditions:
209 
210  ensure(invariant());
211 
212  // Exit:
213 
214  return result;
215 }
216 
217 fiber_bundle::e2_lite::
218 operator const e2_lite::row_dofs_type& () const
219 {
220  // Preconditions:
221 
222  // Body:
223 
224  const row_dofs_type& result = _row_dofs;
225 
226  // Postconditions:
227 
228  ensure(invariant());
229 
230  // Exit:
231 
232  return result;
233 }
234 
235 // PROTECTED MEMBER FUNCTIONS
236 
237 // PRIVATE MEMBER FUNCTIONS
238 
239 
240 //==============================================================================
241 // EUCLIDEAN VECTOR ALGEBRA (ED) FACET OF CLASS E2_LITE
242 //==============================================================================
243 
244 // PUBLIC MEMBER FUNCTIONS
245 
246 // PROTECTED MEMBER FUNCTIONS
247 
248 // PRIVATE MEMBER FUNCTIONS
249 
250 
251 //==============================================================================
252 // EXTERIOR ALGEBRA (AT1) FACET OF CLASS E2_LITE
253 //==============================================================================
254 
255 // PUBLIC MEMBER FUNCTIONS
256 
257 // PROTECTED MEMBER FUNCTIONS
258 
259 // PRIVATE MEMBER FUNCTIONS
260 
261 
262 //==============================================================================
263 // EXTERIOR ALGEBRA (ATP) FACET OF CLASS E2_LITE
264 //==============================================================================
265 
266 // PUBLIC MEMBER FUNCTIONS
267 
268 // PROTECTED MEMBER FUNCTIONS
269 
270 // PRIVATE MEMBER FUNCTIONS
271 
272 
273 //==============================================================================
274 // TENSOR ALGEBRA (TP) FACET OF CLASS E2_LITE
275 //==============================================================================
276 
277 // PUBLIC MEMBER FUNCTIONS
278 
279 int
281 dd() const
282 {
283  // Preconditions:
284 
285  // Body:
286 
287  int result = 2;
288 
289  // Postconditions:
290 
291  ensure(invariant());
292  ensure(result == 2);
293 
294  // Exit:
295 
296  return result;
297 }
298 
299 bool
301 operator==(const e2_lite& xother) const
302 {
303  // cout << endl << "Entering e2_lite::operator==." << endl;
304 
305  // Preconditions:
306 
307  // Body:
308 
309  bool result =
310  (_row_dofs.components[0] == xother._row_dofs.components[0]) &&
311  (_row_dofs.components[1] == xother._row_dofs.components[1]);
312 
313  // Postconditions:
314 
315 
316  // Exit:
317 
318  // cout << "Leaving e2_lite::operator==." << endl;
319  return result;
320 }
321 
322 // PROTECTED MEMBER FUNCTIONS
323 
324 // PRIVATE MEMBER FUNCTIONS
325 
326 
327 //==============================================================================
328 // VECTOR ALGEBRA (VD) FACET OF CLASS E2_LITE
329 //==============================================================================
330 
331 // PUBLIC MEMBER FUNCTIONS
332 
336 {
337  // Preconditions:
338 
339  require(((0 <= xp) && (xp <= 2)) || (xp == 4));
340 
341  // Body:
342 
343  switch(xp)
344  {
345  case 0:
346  {
347  static const at0_lite lat0_lite;
348  return lat0_lite;
349  }
350  case 1:
351  {
352  static const e2_lite le2_lite;
353  return le2_lite;
354  }
355  case 2:
356  {
357  static const t2_e2_lite lt2_e2_lite;
358  return lt2_e2_lite;
359  }
360 
361  // case 3:
362  // static const t3_e2_lite lt3_e2_lite;
363  // return lt3_e2_lite;
364 
365  case 4:
366  {
367  static const t4_e2_lite lt4_e2_lite;
368  return lt4_e2_lite;
369  }
370  default:
371  {
372  // Can't get here because of the precondition.
373  static const tp_lite ltp_lite;
374  return ltp_lite;
375  }
376  }
377 
378  // Postconditions:
379 
380  ensure(unexecutable("result.p() == xp"));
381 
382  // Exit:
383 }
384 
387 tp_prototype(int xp) const
388 {
389  // Preconditions:
390 
391  require(precondition_of(static_tp_prototype(xp)));
392 
393  // Body:
394 
395  const tp_lite& result = static_tp_prototype(xp);
396 
397  // Postconditions:
398 
399  ensure(postcondition_of(static_tp_prototype(xp)));
400 
401  // Exit:
402 
403  return result;
404 }
405 
409 {
410  // Preconditions:
411 
412  require((0 <= xp) && (xp <= 2));
413 
414  // Body:
415 
416  switch(xp)
417  {
418  case 0:
419  {
420  static const at0_lite lat0_lite;
421  return lat0_lite;
422  }
423  case 1:
424  {
425  static const e2_lite le2_lite;
426  return le2_lite;
427  }
428  case 2:
429  {
430  static const at2_e2_lite lat2_e2_lite;
431  return lat2_e2_lite;
432  }
433  default:
434  {
435  // Can't get here because of the precondition.
436  static const atp_lite latp_lite;
437  return latp_lite;
438  }
439  }
440 
441  // Postconditions:
442 
443  ensure(unexecutable("result.p() == xp"));
444 
445  // Exit:
446 }
447 
450 atp_prototype(int xp) const
451 {
452  // Preconditions:
453 
454  require(precondition_of(static_atp_prototype(xp)));
455 
456  // Body:
457 
458  const atp_lite& result = static_atp_prototype(xp);
459 
460  // Postconditions:
461 
462  ensure(postcondition_of(static_atp_prototype(xp)));
463 
464  // Exit:
465 
466  return result;
467 }
468 
472 {
473  // Preconditions:
474 
475  require((2 == xp) || (xp == 4));
476 
477  // Body:
478 
479  switch(xp)
480  {
481  case 2:
482  {
483  static const st2_e2_lite lst2_e2_lite;
484  return lst2_e2_lite;
485  }
486  // case 3:
487  // static const st3_e2_lite lst3_e2_lite;
488  // return lst3_e2_lite;
489  case 4:
490  {
491  static const st4_e2_lite lst4_e2_lite;
492  return lst4_e2_lite;
493  }
494  default:
495  {
496  // Can't get here because of the precondition.
497  static const stp_lite lstp_lite;
498  return lstp_lite;
499  }
500  }
501 
502  // Postconditions:
503 
504  ensure(unexecutable("result.p() == xp"));
505 
506  // Exit:
507 }
508 
511 stp_prototype(int xp) const
512 {
513  // Preconditions:
514 
515  require(precondition_of(static_stp_prototype(xp)));
516 
517  // Body:
518 
519  const stp_lite& result = static_stp_prototype(xp);
520 
521  // Postconditions:
522 
523  ensure(postcondition_of(static_stp_prototype(xp)));
524 
525  // Exit:
526 
527  return result;
528 }
529 
530 
531 // PROTECTED MEMBER FUNCTIONS
532 
533 // PRIVATE MEMBER FUNCTIONS
534 
535 
536 //==============================================================================
537 // CARTESIAN ALGEBRA (TUPLE) FACET OF CLASS E2_LITE
538 //==============================================================================
539 
540 // PUBLIC MEMBER FUNCTIONS
541 
542 // PROTECTED MEMBER FUNCTIONS
543 
544 // PRIVATE MEMBER FUNCTIONS
545 
546 
547 //==============================================================================
548 // ABSTRACT POSET MEMBER FACET OF CLASS E2_LITE
549 //==============================================================================
550 
551 // PUBLIC MEMBER FUNCTIONS
552 
553 const std::string&
555 class_name() const
556 {
557  // Preconditions:
558 
559  // Body:
560 
561  const string& result = static_class_name();
562 
563  // Postconditions:
564 
565  ensure(!result.empty());
566 
567  // Exit:
568 
569  return result;
570 }
571 
572 const std::string&
575 {
576  // Preconditions:
577 
578  // Body:
579 
580  static const string result("e2_lite");
581 
582  // Postconditions:
583 
584  ensure(!result.empty());
585 
586  // Exit:
587 
588  return result;
589 }
590 
593 clone() const
594 {
595  e2_lite* result = 0;
596 
597  // Preconditions:
598 
599  // Body:
600 
601  result = new e2_lite();
602 
603  // Postconditions:
604 
605  ensure(result != 0);
606  ensure(is_same_type(*result));
607 
608  // Exit:
609 
610  return result;
611 }
612 
613 // PROTECTED MEMBER FUNCTIONS
614 
615 // PRIVATE MEMBER FUNCTIONS
616 
617 
618 //==============================================================================
619 // ANY FACET OF CLASS E2_LITE
620 //==============================================================================
621 
622 // PUBLIC MEMBER FUNCTIONS
623 
624 bool
626 is_ancestor_of(const any_lite& xother) const
627 {
628  // Preconditions:
629 
630  require(&xother != 0);
631 
632  // Body:
633 
634  // True if other conforms to this.
635 
636  bool result = dynamic_cast<const e2_lite*>(&xother) != 0;
637 
638  // Postconditions:
639 
640  return result;
641 }
642 
643 bool
645 invariant() const
646 {
647  bool result = true;
648 
649  if(invariant_check())
650  {
651  // Prevent recursive calls to invariant.
652 
653  disable_invariant_check();
654 
655  // Must satisfy base class invariant.
656 
657  invariance(ed_lite::invariant());
658 
659  // Invariances for this class:
660 
661  // Finished, turn invariant checking back on.
662 
663  enable_invariant_check();
664  }
665 
666  // Exit
667 
668  return result;
669 }
670 
671 void*
674 {
675  return &_row_dofs;
676 }
677 
678 const void*
680 row_dofs() const
681 {
682  return &_row_dofs;
683 }
684 
685 // PROTECTED MEMBER FUNCTIONS
686 
687 // PRIVATE MEMBER FUNCTIONS
688 
689 
690 //==============================================================================
691 // CLASS E2
692 //==============================================================================
693 
694 // ===========================================================
695 // HOST FACTORY FACET OF CLASS E2
696 // ===========================================================
697 
698 // PUBLIC MEMBER FUNCTIONS
699 
700 const sheaf::poset_path&
703 {
704  // Preconditions:
705 
706 
707  // Body:
708 
709  static const poset_path result(standard_schema_poset_name(), "e2_schema");
710 
711  // Postconditions:
712 
713  // Exit:
714 
715  return result;
716 }
717 
718 void
721 {
722  // Preconditions:
723 
724  require(xns.state_is_read_write_accessible());
725  require(xns.contains_poset(standard_schema_poset_name()));
726  require(!xns.contains_poset_member(standard_schema_path()));
727 
728  // Body:
729 
730  string lmember_names = "x DOUBLE false y DOUBLE false";
731 
732  schema_poset_member lschema(xns,
733  standard_schema_path().member_name(),
734  ed::standard_schema_path(),
735  lmember_names,
736  false);
737 
738  lschema.detach_from_state();
739 
740  // Postconditions:
741 
742  ensure(xns.contains_poset_member(standard_schema_path()));
743 
744  // Exit:
745 
746  return;
747 }
748 
752  const poset_path& xhost_path,
753  const poset_path& xschema_path,
754  const poset_path& xscalar_space_path,
755  bool xauto_access)
756 {
757  // cout << endl << "Entering e2::new_host." << endl;
758 
759  // Preconditions:
760 
761  require(xns.state_is_auto_read_write_accessible(xauto_access));
762 
763  require(!xhost_path.empty());
764  require(!xns.contains_path(xhost_path, xauto_access));
765 
766  require(xschema_path.full());
767  require(xns.path_is_auto_read_accessible(xschema_path, xauto_access));
768  require(schema_poset_member::conforms_to(xns, xschema_path, standard_schema_path()));
769  require(schema_poset_member::row_dof_ct(xns, xschema_path, xauto_access) == 2);
770 
771  require(xns.path_is_auto_read_accessible(xscalar_space_path, xauto_access));
772  require(xns.contains_poset<scalar_type::host_type>(xscalar_space_path, xauto_access));
773 
774  // Body:
775 
776  host_type& result =
777  host_type::new_table(xns, xhost_path, xschema_path, xscalar_space_path, xauto_access);
778 
779  // Postconditions:
780 
781  ensure(xns.owns(result, xauto_access));
782  ensure(result.path(true) == xhost_path);
783  ensure(result.state_is_not_read_accessible());
784  ensure(result.schema(true).path(xauto_access) == xschema_path);
785 
786  ensure(result.factor_ct(true) == 2);
787  ensure(result.d(true) == 2);
788  ensure(result.scalar_space_path(true) == xscalar_space_path );
789  ensure(result.p(true) == 1);
790  ensure(result.dd(true) == 2);
791  ensure(result.vector_space_path(true) == xhost_path );
792 
793  // Exit:
794 
795  // cout << "Leaving e2::new_host." << endl;
796  return result;
797 }
798 
801 standard_host(namespace_type& xns, const std::string& xsuffix, bool xauto_access)
802 {
803  // cout << endl << "Entering e2::new_host." << endl;
804 
805  // Preconditions:
806 
807  require(xns.state_is_auto_read_write_accessible(xauto_access));
808 
809  require(xsuffix.empty() || poset_path::is_valid_name(xsuffix));
810  require(standard_host_is_available<e2>(xns, xsuffix, xauto_access));
811 
812  require(xns.path_is_auto_read_accessible(standard_schema_path(), xauto_access));
813 
814  require(xns.path_is_auto_read_available(standard_host_path<scalar_type>(xsuffix), xauto_access));
815 
816  // Body:
817 
818  // Create the scalar space if necessary.
819 
820  poset_path lscalar_space_path = scalar_type::standard_host(xns, xsuffix, xauto_access).path(true);
821 
822  poset_path lpath(standard_host_path<e2>(xsuffix));
823 
824  host_type* result_ptr;
825  if(xns.contains_path(lpath, xauto_access))
826  {
827  result_ptr = &xns.member_poset<host_type>(lpath, xauto_access);
828  }
829  else
830  {
831  result_ptr = &new_host(xns, lpath, standard_schema_path(), lscalar_space_path, xauto_access);
832  }
833 
834  host_type& result = *result_ptr;
835 
836  // Postconditions:
837 
838  ensure(xns.owns(result, xauto_access));
839  ensure(result.path(true) == standard_host_path<e2>(xsuffix));
840  ensure(result.state_is_not_read_accessible());
841  ensure(result.schema(true).path(xauto_access) == standard_schema_path());
842 
843  ensure(result.factor_ct(true) == 2);
844  ensure(result.d(true) == 2);
845  ensure(result.scalar_space_path(true) == standard_host_path<scalar_type>(xsuffix) );
846  ensure(result.p(true) == 1);
847  ensure(result.dd(true) == 2);
848  ensure(result.vector_space_path(true) == result.path(true));
849 
850  // Exit:
851 
852  // cout << "Leaving e2::new_host." << endl;
853  return result;
854 }
855 
856 // PROTECTED MEMBER FUNCTIONS
857 
858 // PRIVATE MEMBER FUNCTIONS
859 
860 
861 //==============================================================================
862 // EUCLIDEAN VECTOR ALGEBRA (E2) FACET OF CLASS E2
863 //==============================================================================
864 
865 // PUBLIC MEMBER FUNCTIONS
866 
868 e2()
869 {
870  // Preconditions:
871 
872  // Body:
873 
874  // Postconditions:
875 
876  ensure(invariant());
877 
878  // Exit:
879 }
880 
882 e2(const poset_state_handle* xhost, pod_index_type xhub_id)
883 {
884  // Preconditions:
885 
886  require(xhost != 0);
887  require(xhost->state_is_read_accessible());
888  require(xhost->contains_member(xhub_id));
889 
890  // Body:
891 
892  attach_to_state(xhost, xhub_id);
893 
894  // Postconditions:
895 
896  ensure(invariant());
897  // ensure(host() == xhost);
898  ensure(index() == xhub_id);
899  ensure(is_attached());
900 }
901 
903 e2(const poset_state_handle* xhost, const scoped_index& xid)
904 {
905  // Preconditions:
906 
907  require(xhost != 0);
908  require(xhost->state_is_read_accessible());
909  require(xhost->contains_member(xid));
910 
911  // Body:
912 
913  attach_to_state(xhost, xid.hub_pod());
914 
915  // Postconditions:
916 
917  ensure(invariant());
918  // ensure(host() == xhost);
919  ensure(index() ==~ xid);
920  ensure(is_attached());
921 }
922 
924 e2(const poset_state_handle* xhost, const std::string& xname)
925 {
926 
927  // Preconditions:
928 
929  require(xhost != 0);
930  require(xhost->state_is_read_accessible());
931  require(!xname.empty());
932  require(xhost->contains_member(xname));
933 
934  // Body:
935 
936  attach_to_state(xhost, xname);
937 
938  // Postconditions:
939 
940  ensure(invariant());
941  // ensure(host() == xhost);
942  ensure(name() == xname);
943  ensure(is_attached());
944 
945 }
946 
949 {
950  // Preconditions:
951 
952  require(xother != 0);
953 
954  // Body:
955 
956  attach_to_state(xother);
957 
958  // Postconditions:
959 
960  ensure(invariant());
961  ensure(is_attached());
962  ensure(is_same_state(xother));
963 
964 }
965 
967 e2(poset_state_handle* xhost, bool xauto_access)
968 {
969  // Preconditions:
970 
971  require(precondition_of(new_jim_state(xhost, 0, false, xauto_access)));
972 
973  // Body:
974 
975  new_jim_state(xhost, 0, false, xauto_access);
976 
977  // Postconditions:
978 
979  ensure(postcondition_of(new_jim_state(xhost, 0, false, xauto_access)));
980 
981  // Exit:
982 
983  return;
984 }
985 
988  const row_dofs_type& xrdt,
989  bool xauto_access)
990 {
991 
992  // Preconditions:
993 
994  require(precondition_of(new_jim_state(&xhost, 0, false, xauto_access)));
995 
996  // Body:
997 
998  new_jim_state(&xhost, 0, false, xauto_access);
999 
1000  if(xauto_access)
1001  {
1002  xhost.get_read_write_access();
1003  }
1004 
1005  *this = xrdt;
1006 
1007  if(xauto_access)
1008  {
1009  xhost.release_access();
1010  }
1011 
1012  // Postconditions:
1013 
1014  ensure(postcondition_of(new_jim_state(&xhost, 0, false, xauto_access)));
1015 
1016  // Exit:
1017 
1018  return;
1019 }
1020 
1024 {
1025  // Preconditions:
1026 
1027  require(state_is_read_write_accessible());
1028 
1029  // Body:
1030 
1031  sheaf::row_dofs(*this) = xrdt;
1032 
1033  // Postconditions:
1034 
1035  ensure_for_all(i, 0, d(), component(i) == xrdt.components[i]);
1036 
1037  // Exit:
1038 
1039  return *this;
1040 
1041 }
1042 
1046 {
1047  // Preconditions:
1048 
1049  require(is_ancestor_of(&xother));
1050  require(precondition_of(attach_to_state(&xother)));
1051 
1052  // Body:
1053 
1054  attach_to_state(&xother);
1055 
1056  // Postconditions:
1057 
1058  ensure(postcondition_of(attach_to_state(&xother)));
1059 
1060  // Exit:
1061 
1062  return *this;
1063 }
1064 
1067 operator=(const e2& xother)
1068 {
1069  // Preconditions:
1070 
1071  require(precondition_of(attach_to_state(&xother)));
1072 
1073  // Body:
1074 
1075  attach_to_state(&xother);
1076 
1077  // Postconditions:
1078 
1079  ensure(postcondition_of(attach_to_state(&xother)));
1080 
1081  // Exit:
1082 
1083  return *this;
1084 }
1085 
1088 {
1089 
1090  // Preconditions:
1091 
1092  // Body:
1093 
1094  // Postconditions:
1095 
1096  // Exit:
1097 
1098 }
1099 
1103 {
1104  // Preconditions:
1105 
1106  // Body:
1107 
1108  static const volatile_type result;
1109 
1110  // Postconditions:
1111 
1112  // Exit:
1113 
1114  return result;
1115 }
1116 
1119 lite_type() const
1120 {
1121  // Preconditions:
1122 
1123  // Body:
1124 
1125  volatile_type* result = new volatile_type(sheaf::row_dofs(*this));
1126 
1127  // Postconditions:
1128 
1129  // Exit:
1130 
1131  return result;
1132 }
1133 
1134 // PROTECTED MEMBER FUNCTIONS
1135 
1136 // PRIVATE MEMBER FUNCTIONS
1137 
1138 
1139 //==============================================================================
1140 // EUCLIDEAN VECTOR ALGEBRA (ED) FACET OF CLASS E2
1141 //==============================================================================
1142 
1143 // PUBLIC MEMBER FUNCTIONS
1144 
1145 // PROTECTED MEMBER FUNCTIONS
1146 
1147 // PRIVATE MEMBER FUNCTIONS
1148 
1149 
1150 //==============================================================================
1151 // EXTERIOR ALGEBRA (AT1) FACET OF CLASS E2
1152 //==============================================================================
1153 
1154 // PUBLIC MEMBER FUNCTIONS
1155 
1156 // PROTECTED MEMBER FUNCTIONS
1157 
1158 // PRIVATE MEMBER FUNCTIONS
1159 
1160 
1161 //==============================================================================
1162 // EXTERIOR ALGEBRA (ATP) FACET OF CLASS E2
1163 //==============================================================================
1164 
1165 // PUBLIC MEMBER FUNCTIONS
1166 
1167 // PROTECTED MEMBER FUNCTIONS
1168 
1169 // PRIVATE MEMBER FUNCTIONS
1170 
1171 
1172 //==============================================================================
1173 // TENSOR ALGEBRA (TP) FACET OF CLASS E2
1174 //==============================================================================
1175 
1176 // PUBLIC MEMBER FUNCTIONS
1177 
1178 // PROTECTED MEMBER FUNCTIONS
1179 
1180 // PRIVATE MEMBER FUNCTIONS
1181 
1182 
1183 //==============================================================================
1184 // VECTOR ALGEBRA (VD) FACET OF CLASS E2
1185 //==============================================================================
1186 
1187 // PUBLIC MEMBER FUNCTIONS
1188 
1189 void
1192 {
1193  // Preconditions:
1194 
1195  require(state_is_read_write_accessible());
1196 
1197  // Body:
1198 
1199  put_component(0, xcomp);
1200  put_component(1, ycomp);
1201 
1202  // Postconditions:
1203 
1204  ensure(invariant());
1205  ensure(isunordered_or_equals(component(0), xcomp));
1206  ensure(isunordered_or_equals(component(1), ycomp));
1207 
1208  // Exit:
1209 
1210  return;
1211 }
1212 
1213 fiber_bundle::e2::
1214 operator e2::row_dofs_type& ()
1215 {
1216  // Preconditions:
1217 
1218  // Body:
1219 
1220  row_dofs_type& result = sheaf::row_dofs(*this);
1221 
1222  // Postconditions:
1223 
1224  // Exit:
1225 
1226  return result;
1227 }
1228 
1229 fiber_bundle::e2::
1230 operator const e2::row_dofs_type& () const
1231 {
1232  // Preconditions:
1233 
1234  // Body:
1235 
1236  const row_dofs_type& result = sheaf::row_dofs(*this);
1237 
1238  // Postconditions:
1239 
1240  // Exit:
1241 
1242  return result;
1243 }
1244 
1245 // PROTECTED MEMBER FUNCTIONS
1246 
1247 // PRIVATE MEMBER FUNCTIONS
1248 
1249 
1250 //==============================================================================
1251 // CARTESIAN ALGEBRA (TUPLE) FACET OF CLASS E2
1252 //==============================================================================
1253 
1254 // PUBLIC MEMBER FUNCTIONS
1255 
1258 new_tp(tp_space& xvector_space, int xp)
1259 {
1260  // Preconditions:
1261 
1262  require(xvector_space.state_is_read_accessible());
1263  require(((0 <= xp) && (xp <= 2)) || (xp == 4));
1264 
1265  // Body:
1266 
1267  namespace_poset* lns = xvector_space.name_space();
1268  const string& lvector_space_name = xvector_space.name();
1269 
1270  switch(xp)
1271  {
1272  case 0:
1273  {
1274  const string lname =
1275  create_tensor_space_name(lvector_space_name, "at0");
1276  at0::host_type& lhost = lns->member_poset<at0::host_type>(lname, false);
1277  at0* result = new at0(&lhost);
1278  return result;
1279  }
1280 
1281  case 1:
1282  {
1283  const string lname =
1284  create_tensor_space_name(lvector_space_name, "e2");
1285  e2::host_type& lhost = lns->member_poset<e2::host_type>(lname, false);
1286  e2* result = new e2(&lhost);
1287  return result;
1288  }
1289 
1290  case 2:
1291  {
1292  const string lname =
1293  create_tensor_space_name(lvector_space_name, "t2_e2");
1294  t2_e2::host_type& lhost = lns->member_poset<t2_e2::host_type>(lname, false);
1295  t2_e2* result = new t2_e2(&lhost);
1296  return result;
1297  }
1298 
1299 // case 3: // Don't have t3_e2.
1300 
1301  case 4:
1302  {
1303  const string lname =
1304  create_tensor_space_name(lvector_space_name, "t4_e2");
1305  t4_e2::host_type& lhost = lns->member_poset<t4_e2::host_type>(lname, false);
1306  t4_e2* result = new t4_e2(&lhost);
1307  return result;
1308  }
1309 
1310  default:
1311  // Can't get here because of the precondition.
1312  return 0;
1313  }
1314 
1315  // Postconditions:
1316 
1317  ensure(unexecutable("result.p() == xp"));
1318 
1319  // Exit:
1320 
1321 }
1322 
1325 new_atp(tp_space& xvector_space, int xp)
1326 {
1327  // Preconditions:
1328 
1329  require(xvector_space.state_is_read_accessible());
1330  require((0 <= xp) && (xp <= 2));
1331 
1332  // Body:
1333 
1334  namespace_poset* lns = xvector_space.name_space();
1335  const string& lvector_space_name = xvector_space.name();
1336 
1337  switch(xp)
1338  {
1339  case 0:
1340  {
1341  const string lname =
1342  create_tensor_space_name(lvector_space_name, "at0");
1343  at0::host_type& lhost = lns->member_poset<at0::host_type>(lname, false);
1344  at0* result = new at0(&lhost);
1345  return result;
1346  }
1347 
1348  case 1:
1349  {
1350  const string lname =
1351  create_tensor_space_name(lvector_space_name, "e2");
1352  e2::host_type& lhost = lns->member_poset<e2::host_type>(lname, false);
1353  e2* result = new e2(&lhost);
1354  return result;
1355  }
1356 
1357  case 2:
1358  {
1359  const string lname =
1360  create_tensor_space_name(lvector_space_name, "at2_e2");
1361  at2_e2::host_type& lhost = lns->member_poset<at2_e2::host_type>(lname, false);
1362  at2_e2* result = new at2_e2(&lhost);
1363  return result;
1364  }
1365 
1366  default:
1367  // Can't get here because of the precondition.
1368  return 0;
1369  }
1370 
1371  // Postconditions:
1372 
1373  ensure(unexecutable("result.p() == xp"));
1374 
1375  // Exit:
1376 }
1377 
1380 new_stp(tp_space& xvector_space, int xp)
1381 {
1382  // Preconditions:
1383 
1384  require(xvector_space.state_is_read_accessible());
1385  require((2 == xp) || (xp == 4));
1386 
1387  // Body:
1388 
1389  namespace_poset* lns = xvector_space.name_space();
1390  const string& lvector_space_name = xvector_space.name();
1391 
1392  switch(xp)
1393  {
1394  case 2:
1395  {
1396  const string lname =
1397  create_tensor_space_name(lvector_space_name, "st2_e2");
1398  st2_e2::host_type& lhost = lns->member_poset<st2_e2::host_type>(lname, false);
1399  st2_e2* result = new st2_e2(&lhost);
1400  return result;
1401  }
1402 
1403 // case 3: // Don't have st3_e2.
1404 
1405  case 4:
1406  {
1407  const string lname =
1408  create_tensor_space_name(lvector_space_name, "st4_e2");
1409  st4_e2::host_type& lhost = lns->member_poset<st4_e2::host_type>(lname, false);
1410  st4_e2* result = new st4_e2(&lhost);
1411  return result;
1412  }
1413 
1414  default:
1415  // Can't get here because of the precondition.
1416  return 0;
1417  }
1418 
1419  // Postconditions:
1420 
1421  ensure(unexecutable("result.p() == xp"));
1422 
1423  // Exit:
1424 
1425 }
1426 
1429 new_tp(int xp, bool xauto_access) const
1430 {
1431  // Preconditions:
1432 
1433  require(precondition_of(e2::new_tp(vector_space(xauto_access), xp)));
1434 
1435  // Body:
1436 
1437  tp* result = e2::new_tp(vector_space(xauto_access), xp);
1438 
1439  // Postconditions:
1440 
1441  ensure(postcondition_of(e2::new_tp(vector_space(xauto_access), xp)));
1442 
1443  // Exit:
1444 
1445  return result;
1446 }
1447 
1450 new_atp(int xp, bool xauto_access) const
1451 {
1452  // Preconditions:
1453 
1454  require(precondition_of(e2::new_atp(vector_space(xauto_access), xp)));
1455 
1456  // Body:
1457 
1458  atp* result = e2::new_atp(vector_space(xauto_access), xp);
1459 
1460  // Postconditions:
1461 
1462  ensure(postcondition_of(e2::new_atp(vector_space(xauto_access), xp)));
1463 
1464  // Exit:
1465 
1466  return result;
1467 }
1468 
1471 new_stp(int xp, bool xauto_access) const
1472 {
1473  // Preconditions:
1474 
1475  require(precondition_of(e2::new_stp(vector_space(xauto_access), xp)));
1476 
1477  // Body:
1478 
1479  stp* result = e2::new_stp(vector_space(xauto_access), xp);
1480 
1481  // Postconditions:
1482 
1483  ensure(postcondition_of(e2::new_stp(vector_space(xauto_access), xp)));
1484 
1485  // Exit:
1486 
1487  return result;
1488 }
1489 
1490 
1491 // PROTECTED MEMBER FUNCTIONS
1492 
1493 // PRIVATE MEMBER FUNCTIONS
1494 
1495 
1496 //==============================================================================
1497 // ABSTRACT POSET MEMBER FACET OF CLASS E2
1498 //==============================================================================
1499 
1500 // PUBLIC MEMBER FUNCTIONS
1501 
1502 const std::string&
1504 class_name() const
1505 {
1506  // Preconditions:
1507 
1508  // Body:
1509 
1510  const string& result = static_class_name();
1511 
1512  // Postconditions:
1513 
1514  ensure(!result.empty());
1515 
1516  // Exit:
1517 
1518  return result;
1519 }
1520 
1521 const std::string&
1524 {
1525  // Preconditions:
1526 
1527  // Body:
1528 
1529  static const string result("e2");
1530 
1531  // Postconditions:
1532 
1533  ensure(!result.empty());
1534 
1535  // Exit:
1536 
1537  return result;
1538 }
1539 
1542 clone() const
1543 {
1544 
1545  // Preconditions:
1546 
1547  // Body:
1548 
1549  // Create new handle of the current class..
1550 
1551  e2* result = new e2();
1552 
1553  // Postconditions:
1554 
1555  ensure(result != 0);
1556  ensure(result->invariant());
1557 
1558  // Exit:
1559 
1560  return result;
1561 
1562 }
1563 
1564 // PROTECTED MEMBER FUNCTIONS
1565 
1566 // PRIVATE MEMBER FUNCTIONS
1567 
1568 
1569 //==============================================================================
1570 // ANY FACET OF CLASS E2
1571 //==============================================================================
1572 
1573 // PUBLIC MEMBER FUNCTIONS
1574 
1575 bool
1577 is_ancestor_of(const any* xother) const
1578 {
1579 
1580  // Preconditions:
1581 
1582  require(xother != 0);
1583 
1584  // Body:
1585 
1586  // If other may be dynamically cast to the type of this then this is an
1587  // ancestor of other.
1588 
1589  bool result = dynamic_cast<const e2*>(xother) != 0;
1590 
1591  // Postconditions:
1592 
1593  // ensure(invariant());
1594 
1595  // Exit:
1596 
1597  return result;
1598 
1599 }
1600 
1601 bool
1603 invariant() const
1604 {
1605  bool result = true;
1606 
1607  // Preconditions:
1608 
1609  // Body:
1610 
1611  // Must satisfy base class invariant.
1612 
1613  invariance(ed::invariant());
1614 
1615  if (invariant_check())
1616  {
1617  // Prevent recursive calls to invariant.
1618 
1619  disable_invariant_check();
1620 
1621  invariance((is_attached() ? d() == 2 : true));
1622 
1623  // Finished, turn invariant checking back on.
1624 
1625  enable_invariant_check();
1626  }
1627 
1628  // Postconditions:
1629 
1630  ensure(is_derived_query);
1631 
1632  // Exit:
1633 
1634  return result;
1635 }
1636 
1637 // PROTECTED MEMBER FUNCTIONS
1638 
1639 // PRIVATE MEMBER FUNCTIONS
1640 
1641 
1642 //==============================================================================
1643 // NON-MEMBER FUNCTIONS
1644 //==============================================================================
1645 
1648 perp_dot(const e2_lite& x0, const e2_lite& x1)
1649 {
1650  // cout << endl << "Entering e2::perp_dot." << endl;
1651 
1652  // Preconditions:
1653 
1654 
1655  // Body:
1656 
1657  // Result = dot(x0-perp, x1), where x0-perp = (-x0[1], x0[0]).
1658  // = -x0[1]*x1[0] + x0[0]*x1[1]
1659 
1660  const e2_lite::dof_type* lx0 = reinterpret_cast<const e2_lite::row_dofs_type*>(x0.row_dofs())->components;
1661  const e2_lite::dof_type* lx1 = reinterpret_cast<const e2_lite::row_dofs_type*>(x1.row_dofs())->components;
1662 
1663  vd_value_type result = -lx0[1]*lx1[0] + lx0[0]*lx1[1];
1664 
1665  // Postconditions:
1666 
1667 
1668  // Exit:
1669 
1670  // cout << "Leaving e2::perp_dot." << endl;
1671  return result;
1672 }
1673 
T components[2]
The components (row_dofs).
Definition: e2.h:96
virtual void get_read_write_access(bool xrelease_read_only_access=false)
Get read write access to the state associated with this. If release_read_only_access is requested...
virtual poset_path path(bool xauto_access=true) const
The path of this poset.
bool state_is_auto_read_write_accessible(bool xauto_access) const
True if state is auto accessible for read and write, that is, if the state is already accessible for ...
A symmetric tensor of degree p over an abstract vector space.
Definition: stp.h:190
vd_value_type value_type
The type of component in the fiber; the scalar type in the fiber vector space.
Definition: vd.h:129
static void make_standard_schema(namespace_poset &xns)
Creates the standard schema for this class in namespace xns.
Definition: e2.cc:720
bool full() const
True if both poset name and member name are not empty.
Definition: poset_path.cc:311
static const std::string & static_class_name()
The name of this class.
Definition: e2.cc:1523
An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 2 (persistent version)...
Definition: at2_e2.h:412
An antisymmetric tensor of degree p.
Definition: atp.h:190
virtual const atp_lite & atp_prototype(int xp) const
Prototype for antisymmetric tensors of degree xp over this vector space.
Definition: e2.cc:450
static int d(const namespace_poset &xns, int xp, const poset_path &xvector_space_path, bool xauto_access)
The tensor dimension implied by tensor degree xp and the dimension of the domain vector space specifi...
Definition: atp_space.cc:86
Euclidean vector space of dimension 2 (persistent version).
Definition: e2.h:405
A tensor of degree 2 over a Euclidean vector space of dimension 2 (volatile version).
Definition: t2_e2.h:148
poset_path path(bool xauto_access=true) const
A path to this component.
virtual void * row_dofs()
The row dofs for this instance (mutable version).
Definition: e2.cc:673
The default name space; a poset which contains other posets as members.
bool state_is_read_accessible() const
True if this is attached and if the state is accessible for read or access control is disabled...
static const tp_lite & static_tp_prototype(int xp)
Static prototype for general tensors of degree xp over this vector space.
Definition: e2.cc:335
bool path_is_auto_read_accessible(const poset_path &xpath, bool xauto_access) const
True if the state referred to xpath exists and is auto read accessible.
The standard fiber bundles name space; extends the standard sheaves namespace by defining base space...
A tensor of degree 2 over a Euclidean vector space of dimension 2 (persistent version).
Definition: t2_e2.h:444
poset_path vector_space_path() const
The path of the underlying vector space.
Definition: tp_space.cc:365
A general antisymmetric tensor of degree 1 over an abstract vector space (volatile version)...
Definition: at1.h:44
bool contains_poset_member(pod_index_type xposet_hub_id, pod_index_type xmember_hub_id, bool xauto_access=true) const
True if this contains a poset with hub id xposet_hub_id which contains a member with hub id xmember_h...
A client handle for a general, abstract partially order set.
virtual const tp_lite & tp_prototype(int xp) const
Prototype for general tensors of degree xp over this vector space.
Definition: e2.cc:387
A path defined by a poset name and a member name separated by a forward slash (&#39;/&#39;). For example: "cell_definitions/triangle".
Definition: poset_path.h:48
A tensor of degree 4 over a Euclidean vector space of dimension 2 (persistent version).
Definition: t4_e2.h:378
STL namespace.
virtual const volatile_type & lite_prototype() const
Virtual constructor for the associated volatile type.
Definition: e2.cc:1102
poset_state_handle & member_poset(pod_index_type xhub_id, bool xauto_access=true) const
The poset_state_handle object referred to by hub id xhub_id.
An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 2 (volatile version)...
Definition: at2_e2.h:146
T::row_dofs_type & row_dofs(T &x0)
The row dofs pod type for x0 (mutable version).
static tp * new_tp(tp_space &xvector_space, int xp)
Static constructor for general tensors of degree xp over vector space xvector_space.
Definition: e2.cc:1258
virtual const std::string & class_name() const
The name of this class.
Definition: e2.cc:1504
e2_lite()
Default constructor.
Definition: e2.cc:56
An antisymmetric tensor of degree p over an abstract vector space (volatile version).
Definition: atp.h:44
A general tensor of "degree" p and given "variance" over an abstract vector space.
Definition: tp.h:253
bool operator==(const e2_lite &xother) const
True if this has the same components as xother.
Definition: e2.cc:301
Abstract base class with useful features for all volatile objects.
Definition: any_lite.h:48
Abstract base class with useful features for all objects.
Definition: any.h:39
virtual schema_poset_member & schema()
The schema for this poset (mutable version).
bool invariant() const
Class invariant.
Definition: e2.cc:1603
A space of scalars viewed as an antisymmetric tensor space of degree 0.
Definition: at0_space.h:42
Euclidean vector space of dimension 2 (volatile version).
Definition: e2.h:112
An abstract antisymmetric tensor space of degree p.
Definition: atp_space.h:42
virtual ~e2_lite()
Destructor.
Definition: e2.cc:111
static host_type & standard_host(namespace_type &xns, const std::string &xsuffix, bool xauto_access)
The host with path standard_host_path<e2>(xsuffix). Returns the host if it already exists...
Definition: e2.cc:801
bool state_is_read_write_accessible() const
True if this is attached and if the state is accessible for read and write or access control is disab...
virtual volatile_type * lite_type() const
Virtual conversion to the associated volatile type.
Definition: e2.cc:1119
e2 & operator=(const row_dofs_type &xrdt)
Assignment to an instance of the associated row dofs type.
Definition: e2.cc:1023
static const poset_path & standard_schema_path()
The path to the standard schema for this class.
Definition: e2.cc:702
bool owns(const poset_state_handle &xposet, bool xauto_access) const
True if and only if this contains the poset xposet. synonym for contains_poset(xposet.poset_path(true), xauto_access)
virtual void detach_from_state()
Detach this handle from its state, if any.
An index within the external ("client") scope of a given id space.
Definition: scoped_index.h:116
A scalar viewed as an antisymmetric tensor of degree 0. As the degree is 0 there is nothing to be sym...
Definition: at0.h:424
static atp * new_atp(tp_space &xvector_space, int xp)
Static constructor for antisymmetric tensors of degree xp over vector space xvector_space.
Definition: e2.cc:1325
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
Antisymetric tensor of degree 0 (volatile version).
Definition: at0.h:127
SHEAF_DLL_SPEC vd_value_type perp_dot(const e2_lite &x0, const e2_lite &x1)
The perp-dot pseudo cross product of x0 with x1 (version for persistent types).
Definition: e2.cc:1648
virtual bool contains_member(pod_index_type xmbr_hub_id, bool xauto_access=true) const
True if some version of this poset contains poset member with hub id xmbr_hub_id. ...
int p(int xd, int xdd) const
Tensor degree as a function of tensor dimension xd and domain dimension xdd.
Definition: tp_space.cc:235
static const std::string & static_class_name()
The name of this class.
Definition: e2.cc:574
vd_dof_type dof_type
The type of the degrees of freedom.
Definition: vd.h:123
e2()
Default constructor.
Definition: e2.cc:868
e2_lite & operator=(const e2_lite &xother)
Assignment operator.
Definition: e2.cc:88
A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version).
Definition: st4_e2.h:376
virtual std::string name() const
The name of this poset.
bool empty() const
True if both poset name and member name are empty.
Definition: poset_path.cc:291
virtual void release_access(bool xall=false) const
Release access. If xall is true, release all levels of access. Otherwise, release one level of access...
bool invariant() const
Class invariant.
Definition: e2.cc:645
A general tensor of degree p over an abstract vector space (volatile version). Volatile version does ...
Definition: tp.h:59
virtual e2_lite * clone() const
Virtual constructor, makes a new instance of the same type as this.
Definition: e2.cc:593
static stp * new_stp(tp_space &xvector_space, int xp)
Static constructor for symmetric tensors of degree xp over vector space xvector_space.
Definition: e2.cc:1380
bool contains_poset(pod_index_type xhub_id, bool xauto_access=true) const
True if this contains a poset with hub id xhub_id..
A symmetric rank 4 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: st4_e2.h:124
bool path_is_auto_read_available(const poset_path &xpath, bool xauto_access) const
True if the state referred to xpath does not exist or exists and is auto read accessible.
row_dofs_type _row_dofs
Row_dofs_type.
Definition: e2.h:189
virtual e2 * clone() const
Make a new handle, no state instance of current.
Definition: e2.cc:1542
poset_path scalar_space_path() const
The path of the underlying space of scalars.
Definition: vd_space.cc:250
static host_type & new_host(namespace_type &xns, const poset_path &xhost_path, const poset_path &xschema_path, const poset_path &xscalar_space_path, bool xauto_access)
Creates a new host table for members of this type. The poset is created in namespace xns with path xh...
Definition: e2.cc:751
static const atp_lite & static_atp_prototype(int xp)
Static prototype for antisymmetric tensors of degree xp over this vector space.
Definition: e2.cc:408
namespace_poset * name_space() const
The namespace this poset resides in.
virtual const std::string & class_name() const
The name of this class.
Definition: e2.cc:555
An abstract vector space viewed as an antisymmetric tensor space of degree 1.
Definition: at1_space.h:42
virtual const stp_lite & stp_prototype(int xp) const
Prototype for symmetric tensors of degree xp over this vector space.
Definition: e2.cc:511
static int factor_ct(int xd)
Factor_ct() as a function of dimension xd.
Definition: vd_space.cc:167
int_type pod_index_type
The plain old data index type.
Definition: pod_types.h:49
A symmetric tensor of degree 2 over a Euclidean vector space of dimension 2 (persistent version)...
Definition: st2_e2.h:431
int dd() const
The dimension of the underlying ("domain") vector space.
Definition: tp_space.cc:317
bool is_ancestor_of(const any *xother) const
True if other conforms to current.
Definition: e2.cc:1577
virtual void put_components(dof_type x_comp, dof_type y_comp)
Set values of the components to the given arguments.
Definition: e2.cc:1191
virtual void put_components(const value_type &x_comp, const value_type &y_comp)
Set values of the components to the given arguments.
Definition: e2.cc:180
A symmetric tensor of degree 2 over a Euclidean vector space of dimension 2 (volatile version)...
Definition: st2_e2.h:150
~e2()
Destructor.
Definition: e2.cc:1087
An abstract client handle for a member of a poset.
A tensor of degree 4 over a Euclidean vector space of dimension 2 (volatile version).
Definition: t4_e2.h:140
std::string path() const
The full path as a string.
Definition: poset_path.cc:450
vd_dof_type dof_type
The type of the degrees of freedom. Note that although dof_type == value_type in this implementation...
Definition: vd.h:431
An abstract tensor space of degree p.
Definition: tp_space.h:47
A symmetric tensor of degree p over an abstract vector space (volatile version).
Definition: stp.h:44
An abstract symmetric tensor space of degree p.
Definition: stp_space.h:42
Namespace for the fiber_bundles component of the sheaf system.
virtual bool is_ancestor_of(const any_lite &xother) const
Conformance test; true if other conforms to this.
Definition: e2.cc:626
bool state_is_not_read_accessible() const
True if this is attached and if the state is accessible for read or if access control is disabled...
static const stp_lite & static_stp_prototype(int xp)
Static prototype for symmetric tensors of degree xp over this vector space.
Definition: e2.cc:471
A client handle for a poset member which has been prepared for use as a schema.
double vd_value_type
The type of component in the fiber; the scalar type in the fiber vector space.
Definition: fiber_bundle.h:63
pod_type hub_pod() const
The pod value of this mapped to the unglued hub id space.
Definition: scoped_index.h:710
virtual int dd() const
Dimension of the underlying vector space.
Definition: e2.cc:281
SHEAF_DLL_SPEC bool isunordered_or_equals(float x1, float x2)
True if isunordered(x1, x2) or x1 == x2.
Definition: sheaf.cc:102