SheafSystem  0.0.0.0
at3_e3.cc
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 
18 // Implementation for class at3_e3.
19 
20 #include "SheafSystem/at3_e3.impl.h"
21 
22 #include "SheafSystem/abstract_poset_member.impl.h"
23 #include "SheafSystem/assert_contract.h"
24 #include "SheafSystem/at0.h"
25 #include "SheafSystem/at1_space.h"
26 #include "SheafSystem/fiber_bundles_namespace.h"
27 #include "SheafSystem/schema_poset_member.h"
28 #include "SheafSystem/wsv_block.h"
29 
30 using namespace std;
31 using namespace fiber_bundle; // Workaround for MS C++ bug.
32 
33 
34 //==============================================================================
35 // CLASS AT3_E3_LITE
36 //==============================================================================
37 
38 //==============================================================================
39 // AT3_E3 FACET OF CLASS ST2_E3_LITE
40 //==============================================================================
41 
42 // PUBLIC MEMBER FUNCTIONS
43 
46 {
47 
48  // Preconditions:
49 
50  // Body:
51 
52  // Postconditions:
53 
54  ensure(invariant());
55 
56  // Exit:
57 }
58 
60 at3_e3_lite(const at3_e3_lite& xother)
61 {
62  // Preconditions:
63 
64  // Body:
65 
66  *this = xother;
67 
68  // Postconditions:
69 
70  ensure(invariant());
71 
72  // Exit:
73 }
74 
77 operator=(const at3_e3_lite& xother)
78 {
79 
80  // Preconditions:
81 
82  // Body:
83 
84  if(this == &xother)
85  return *this;
86 
87  _row_dofs = xother._row_dofs;
88 
89  // Postconditions:
90 
91  ensure(invariant());
92 
93  // Exit:
94 
95  return *this;
96 }
97 
100 {
101  // Preconditions:
102 
103  // Body:
104 
105  // Postconditions:
106 
107  // Exit:
108 }
109 
111 at3_e3_lite(const row_dofs_type& xrow_dofs)
112 {
113  // Preconditions:
114 
115  // Body:
116 
117  *this = xrow_dofs;
118 
119  // Postconditions:
120 
121  ensure(invariant());
122 
123  // Exit:
124 }
125 
128 operator=(const row_dofs_type& xrow_dofs)
129 {
130  // Preconditions:
131 
132  // Body:
133 
134  _row_dofs = xrow_dofs;
135 
136  // Postconditions:
137 
138  ensure(invariant());
139 
140  // Exit:
141 
142  return *this;
143 
144 }
145 
146 fiber_bundle::at3_e3_lite::
148 {
149  // Preconditions:
150 
151  // Body:
152 
153  row_dofs_type& result = _row_dofs;
154 
155  // Postconditions:
156 
157  // Exit:
158 
159  return result;
160 }
161 
162 fiber_bundle::at3_e3_lite::
163 operator const at3_e3_lite::row_dofs_type& () const
164 {
165  // Preconditions:
166 
167  // Body:
168 
169  const row_dofs_type& result = _row_dofs;
170 
171  // Postconditions:
172 
173  // Exit:
174 
175  return result;
176 }
177 
178 
180 at3_e3_lite(const value_type& xcomp)
181 {
182  // Preconditions:
183 
184  // Body:
185 
186  put_components(xcomp);
187 
188  // Postconditions:
189 
190  // Exit:
191 }
192 
193 void
196 {
197  // Preconditions:
198 
199  // Body:
200 
201  put_component(0, xcomp);
202 
203  // Postconditions:
204 
205  ensure(invariant());
206  ensure(isunordered_or_equals(component(0), xcomp));
207 
208  // Exit:
209 }
210 
211 // PROTECTED MEMBER FUNCTIONS
212 
213 // PRIVATE MEMBER FUNCTIONS
214 
215 
216 //==============================================================================
217 // INTERIOR ALGEBRA (AT3) FACET OF CLASS AT3_E3_LITE
218 //==============================================================================
219 
220 // PUBLIC MEMBER FUNCTIONS
221 
222 // PROTECTED MEMBER FUNCTIONS
223 
224 // PRIVATE MEMBER FUNCTIONS
225 
226 
227 //==============================================================================
228 // EXTERIOR ALGEBRA (ATP) FACET OF CLASS AT3_E3_LITE
229 //==============================================================================
230 
231 // PUBLIC MEMBER FUNCTIONS
232 
233 // PROTECTED MEMBER FUNCTIONS
234 
235 // PRIVATE MEMBER FUNCTIONS
236 
237 
238 //==============================================================================
239 // TENSOR ALGEBRA (TP) FACET OF CLASS AT3_E3_LITE
240 //==============================================================================
241 
242 // PUBLIC MEMBER FUNCTIONS
243 
244 int
246 dd() const
247 {
248  // Preconditions:
249 
250  // Body:
251 
252  int result = 3;
253 
254  // Postconditions:
255 
256  ensure(invariant());
257  ensure(result == 3);
258 
259  // Exit:
260 
261  return result;
262 }
263 
264 // PROTECTED MEMBER FUNCTIONS
265 
266 // PRIVATE MEMBER FUNCTIONS
267 
268 
269 //==============================================================================
270 // VECTOR ALGEBRA (VD) FACET OF CLASS AT3_E3_LITE
271 //==============================================================================
272 
273 // PUBLIC MEMBER FUNCTIONS
274 
277 tp_prototype(int xp) const
278 {
279  // Preconditions:
280 
281  require(precondition_of(e3_lite::static_tp_prototype(xp)));
282 
283  // Body:
284 
285  const tp_lite& result = e3_lite::static_tp_prototype(xp);
286 
287  // Postconditions:
288 
289  ensure(postcondition_of(e3_lite::static_tp_prototype(xp)));
290 
291  // Exit:
292 
293  return result;
294 }
295 
298 atp_prototype(int xp) const
299 {
300  // Preconditions:
301 
302  require(precondition_of(e3_lite::static_atp_prototype(xp)));
303 
304  // Body:
305 
306  const atp_lite& result = e3_lite::static_atp_prototype(xp);
307 
308  // Postconditions:
309 
310  ensure(postcondition_of(e3_lite::static_atp_prototype(xp)));
311 
312  // Exit:
313 
314  return result;
315 }
316 
319 stp_prototype(int xp) const
320 {
321  // Preconditions:
322 
323  require(precondition_of(e3_lite::static_stp_prototype(xp)));
324 
325  // Body:
326 
327  const stp_lite& result = e3_lite::static_stp_prototype(xp);
328 
329  // Postconditions:
330 
331  ensure(postcondition_of(e3_lite::static_stp_prototype(xp)));
332 
333  // Exit:
334 
335  return result;
336 }
337 
338 // PROTECTED MEMBER FUNCTIONS
339 
340 // PRIVATE MEMBER FUNCTIONS
341 
342 
343 //==============================================================================
344 // CARTESIAN ALGEBRA (TUPLE) FACET OF CLASS AT3_E3_LITE
345 //==============================================================================
346 
347 // PUBLIC MEMBER FUNCTIONS
348 
349 // PROTECTED MEMBER FUNCTIONS
350 
351 // PRIVATE MEMBER FUNCTIONS
352 
353 
354 //==============================================================================
355 // ABSTRACT POSET MEMBER FACET OF CLASS AT3_E3_LITE
356 //==============================================================================
357 
358 // PUBLIC MEMBER FUNCTIONS
359 
360 const std::string&
362 class_name() const
363 {
364  // Preconditions:
365 
366  // Body:
367 
368  const string& result = static_class_name();
369 
370  // Postconditions:
371 
372  ensure(!result.empty());
373 
374  // Exit:
375 
376  return result;
377 }
378 
379 const std::string&
382 {
383  // Preconditions:
384 
385  // Body:
386 
387  static const string result("at3_e3_lite");
388 
389  // Postconditions:
390 
391  ensure(!result.empty());
392 
393  // Exit:
394 
395  return result;
396 }
397 
400 clone() const
401 {
402  at3_e3_lite* result = 0;
403 
404  // Preconditions:
405 
406  // Body:
407 
408  result = new at3_e3_lite();
409 
410  // Postconditions:
411 
412  ensure(result != 0);
413  ensure(is_same_type(*result));
414 
415  // Exit:
416 
417  return result;
418 }
419 
420 // PROTECTED MEMBER FUNCTIONS
421 
422 // PRIVATE MEMBER FUNCTIONS
423 
424 
425 //==============================================================================
426 // ANY FACET OF CLASS AT3_E3_LITE
427 //==============================================================================
428 
429 // PUBLIC MEMBER FUNCTIONS
430 
431 bool
433 is_ancestor_of(const any_lite& xother) const
434 {
435  // Preconditions:
436 
437  require(&xother != 0);
438 
439  // Body:
440 
441  // True if other conforms to this.
442 
443  bool result = dynamic_cast<const at3_e3_lite*>(&xother) != 0;
444 
445  // Postconditions:
446 
447  return result;
448 }
449 
450 bool
452 invariant() const
453 {
454  bool result = true;
455 
456  if(invariant_check())
457  {
458  // Prevent recursive calls to invariant.
459 
460  disable_invariant_check();
461 
462  // Must satisfy base class invariant.
463 
464  invariance(at3_lite::invariant());
465 
466  // Invariances for this class:
467 
468  // Finished, turn invariant checking back on.
469 
470  enable_invariant_check();
471  }
472 
473  // Exit
474 
475  return result;
476 }
477 
478 void*
481 {
482  return &_row_dofs;
483 }
484 
485 const void*
487 row_dofs() const
488 {
489  return &_row_dofs;
490 }
491 
492 // PROTECTED MEMBER FUNCTIONS
493 
494 // PRIVATE MEMBER FUNCTIONS
495 
496 
497 //==============================================================================
498 // CLASS AT3_E3
499 //==============================================================================
500 
501 // ===========================================================
502 // HOST FACTORY FACET OF CLASS AT3_E3
503 // ===========================================================
504 
505 // PUBLIC MEMBER FUNCTIONS
506 
507 const sheaf::poset_path&
510 {
511  // Preconditions:
512 
513 
514  // Body:
515 
516  static const poset_path result(standard_schema_poset_name(), "at3_e3_schema");
517 
518  // Postconditions:
519 
520  // Exit:
521 
522  return result;
523 }
524 
525 void
528 {
529  // Preconditions:
530 
531  require(xns.state_is_read_write_accessible());
532  require(xns.contains_poset(standard_schema_poset_name()));
533  require(!xns.contains_poset_member(standard_schema_path()));
534 
535 
536  // Body:
537 
538  string lmember_names = "component DOUBLE false ";
539 
540  schema_poset_member lschema(xns,
541  standard_schema_path().member_name(),
542  at3::standard_schema_path(),
543  lmember_names,
544  false);
545 
546  lschema.detach_from_state();
547 
548  // Postconditions:
549 
550  ensure(xns.contains_poset_member(standard_schema_path()));
551 
552  // Exit:
553 
554  return;
555 }
556 
560  const poset_path& xhost_path,
561  const poset_path& xschema_path,
562  const poset_path& xvector_space_path,
563  bool xauto_access)
564 {
565  // cout << endl << "Entering at3_e3::new_host." << endl;
566 
567  // Preconditions:
568 
569  require(xns.state_is_auto_read_write_accessible(xauto_access));
570 
571  require(!xhost_path.empty());
572  require(!xns.contains_path(xhost_path, xauto_access));
573 
574  require(xschema_path.full());
575  require(xns.path_is_auto_read_accessible(xschema_path, xauto_access));
576  require(schema_poset_member::conforms_to(xns, xschema_path, standard_schema_path()));
577  require(schema_poset_member::row_dof_ct(xns, xschema_path, xauto_access) == 1);
578 
579  require(xns.path_is_auto_read_accessible(xvector_space_path, xauto_access));
580  require(xns.contains_poset<vector_space_type::host_type>(xvector_space_path, xauto_access));
581  require(xns.member_poset(xvector_space_path, xauto_access).schema(xauto_access).conforms_to(vector_space_type::standard_schema_path()));
582  require(xns.member_poset<vector_space_type::host_type>(xvector_space_path, xauto_access).d(xauto_access) == 3);
583 
584  // Body:
585 
586  host_type& result =
587  host_type::new_table(xns, xhost_path, xschema_path, 3, xvector_space_path, xauto_access);
588 
589  // Postconditions:
590 
591  ensure(xns.owns(result, xauto_access));
592  ensure(result.path(true) == xhost_path);
593  ensure(result.state_is_not_read_accessible());
594  ensure(result.schema(true).path(xauto_access) == xschema_path);
595 
596  ensure(result.factor_ct(true) == 1);
597  ensure(result.d(true) == 1);
598  ensure(result.scalar_space_path(true) == xns.member_poset<vector_space_type::host_type>(xvector_space_path, xauto_access).scalar_space_path());
599  ensure(result.p(true) == 3);
600  ensure(result.dd(true) == 3);
601  ensure(result.vector_space_path(true) == xvector_space_path);
602 
603  // Exit:
604 
605  // cout << "Leaving at3_e3::new_host." << endl;
606  return result;
607 }
608 
611 standard_host(namespace_type& xns, const std::string& xsuffix, bool xauto_access)
612 {
613  // cout << endl << "Entering at3_e3::new_host." << endl;
614 
615  // Preconditions:
616 
617  require(xns.state_is_auto_read_write_accessible(xauto_access));
618 
619  require(xsuffix.empty() || poset_path::is_valid_name(xsuffix));
620  require(standard_host_is_available<at3_e3>(xns, xsuffix, xauto_access));
621 
622  require(xns.path_is_auto_read_accessible(standard_schema_path(), xauto_access));
623 
624  require(xns.path_is_auto_read_available(standard_host_path<vector_space_type>(xsuffix), xauto_access));
625 
626  // Body:
627 
628  // Create the vector space if necessary.
629 
630  poset_path lvector_space_path = vector_space_type::standard_host(xns, xsuffix, xauto_access).path(true);
631 
632  poset_path lpath(standard_host_path<at3_e3>(xsuffix));
633 
634  host_type* result_ptr;
635  if(xns.contains_path(lpath, xauto_access))
636  {
637  result_ptr = &xns.member_poset<host_type>(lpath, xauto_access);
638  }
639  else
640  {
641  result_ptr = &new_host(xns, lpath, standard_schema_path(), lvector_space_path, xauto_access);
642  }
643 
644  host_type& result = *result_ptr;
645 
646  // Postconditions:
647 
648  ensure(xns.owns(result, xauto_access));
649  ensure(result.path(true) == standard_host_path<at3_e3>(xsuffix));
650  ensure(result.state_is_not_read_accessible());
651  ensure(result.schema(true).path(xauto_access) == standard_schema_path());
652 
653  ensure(result.factor_ct(true) == 1);
654  ensure(result.d(true) == 1);
655  ensure(result.scalar_space_path(true) == standard_host_path<vector_space_type::scalar_type>(xsuffix) );
656  ensure(result.p(true) == 3);
657  ensure(result.dd(true) == 3);
658  ensure(result.vector_space_path(true) == standard_host_path<vector_space_type>(xsuffix) );
659 
660  // Exit:
661 
662  // cout << "Leaving at3_e3::new_host." << endl;
663  return result;
664 }
665 
666 // PROTECTED MEMBER FUNCTIONS
667 
668 // PRIVATE MEMBER FUNCTIONS
669 
670 
671 //==============================================================================
672 // AT3_E3 FACET
673 //==============================================================================
674 
675 // PUBLIC MEMBER FUNCTIONS
676 
679 {
680 
681  // Preconditions:
682 
683  // Body:
684 
685  // Postconditions:
686 
687  ensure(invariant());
688 }
689 
692 {
693  // Preconditions:
694 
695  require(xhost != 0);
696  require(xhost->state_is_read_accessible());
697  require(xhost->contains_member(xhub_id));
698 
699  // Body:
700 
701  attach_to_state(xhost, xhub_id);
702 
703  // Postconditions:
704 
705  ensure(invariant());
706  // ensure(host() == xhost);
707  ensure(index() == xhub_id);
708  ensure(is_attached());
709 }
710 
712 at3_e3(const poset_state_handle* xhost, const scoped_index& xid)
713 {
714  // Preconditions:
715 
716  require(xhost != 0);
717  require(xhost->state_is_read_accessible());
718  require(xhost->contains_member(xid));
719 
720  // Body:
721 
722  attach_to_state(xhost, xid.hub_pod());
723 
724  // Postconditions:
725 
726  ensure(invariant());
727  // ensure(host() == xhost);
728  ensure(index() ==~ xid);
729  ensure(is_attached());
730 }
731 
733 at3_e3(const poset_state_handle* xhost, const std::string& xname)
734 {
735 
736  // Preconditions:
737 
738  require(xhost != 0);
739  require(xhost->state_is_read_accessible());
740  require(!xname.empty());
741  require(xhost->contains_member(xname));
742 
743  // Body:
744 
745  attach_to_state(xhost, xname);
746 
747  // Postconditions:
748 
749  ensure(invariant());
750  // ensure(host() == xhost);
751  ensure(name() == xname);
752  ensure(is_attached());
753 
754 }
755 
758 {
759 
760  // Preconditions:
761 
762  require(xother != 0);
763 
764  // Body:
765 
766  attach_to_state(xother);
767 
768  // Postconditions:
769 
770  ensure(invariant());
771  ensure(is_attached());
772  ensure(is_same_state(xother));
773 
774 }
775 
777 at3_e3(poset_state_handle* xhost, bool xauto_access)
778 {
779 
780  // Preconditions:
781 
782  require(precondition_of(new_jim_state(xhost, 0, false, xauto_access)));
783 
784  // Body:
785 
786  new_jim_state(xhost, 0, false, xauto_access);
787 
788  // Postconditions:
789 
790  ensure(postcondition_of(new_jim_state(xhost, 0, false, xauto_access)));
791 
792  // Exit:
793 
794  return;
795 }
796 
799  const row_dofs_type& xrdt,
800  bool xauto_access)
801 {
802 
803  // Preconditions:
804 
805  require(precondition_of(new_jim_state(&xhost, 0, false, xauto_access)));
806 
807  // Body:
808 
809  new_jim_state(&xhost, 0, false, xauto_access);
810 
811  if(xauto_access)
812  {
813  xhost.get_read_write_access();
814  }
815 
816  *this = xrdt;
817 
818  if(xauto_access)
819  {
820  xhost.release_access();
821  }
822 
823  // Postconditions:
824 
825  ensure(postcondition_of(new_jim_state(&xhost, 0, false, xauto_access)));
826 
827  // Exit:
828 
829  return;
830 }
831 
832 
836 {
837  // Preconditions:
838 
839  require(state_is_read_write_accessible());
840 
841  // Body:
842 
843  sheaf::row_dofs(*this) = xrdt;
844 
845  // Postconditions:
846 
847  ensure_for_all(i, 0, d(), component(i) == xrdt.components[i]);
848 
849  // Exit:
850 
851  return *this;
852 
853 }
854 
859 {
860  // Preconditions:
861 
862  require(is_ancestor_of(&xother));
863  require(precondition_of(attach_to_state(&xother)));
864 
865  // Body:
866 
867  attach_to_state(&xother);
868 
869  // Postconditions:
870 
871  ensure(postcondition_of(attach_to_state(&xother)));
872 
873  // Exit:
874 
875  return *this;
876 }
877 
881 operator=(const at3_e3& xother)
882 {
883  // Preconditions:
884 
885  require(precondition_of(attach_to_state(&xother)));
886 
887  // Body:
888 
889  attach_to_state(&xother);
890 
891  // Postconditions:
892 
893  ensure(postcondition_of(attach_to_state(&xother)));
894 
895  // Exit:
896 
897  return *this;
898 }
899 
902 {
903 
904  // Preconditions:
905 
906  // Body:
907 
908  // Postconditions:
909 
910 }
911 
915 {
916  // Preconditions:
917 
918  // Body:
919 
920  static const volatile_type result;
921 
922  // Postconditions:
923 
924  // Exit:
925 
926  return result;
927 }
928 
932 lite_type() const
933 {
934  // Preconditions:
935 
936  // Body:
937 
938  volatile_type* result = new volatile_type(sheaf::row_dofs(*this));
939 
940  // Postconditions:
941 
942  // Exit:
943 
944  return result;
945 }
946 
947 
948 void
951 {
952  // Preconditions:
953 
954  require(state_is_read_write_accessible());
955 
956  // Body:
957 
958  put_component(0, xcomp);
959 
960  // Postconditions:
961 
962  ensure(invariant());
963  ensure(isunordered_or_equals(component(0), xcomp));
964 
965  // Exit:
966 
967  return;
968 }
969 
970 fiber_bundle::at3_e3::
972 {
973  // Preconditions:
974 
975  // Body:
976 
977  row_dofs_type& result = sheaf::row_dofs(*this);
978 
979  // Postconditions:
980 
981  // Exit:
982 
983  return result;
984 }
985 
986 fiber_bundle::at3_e3::
987 operator const at3_e3::row_dofs_type& () const
988 {
989  // Preconditions:
990 
991  // Body:
992 
993  const row_dofs_type& result = sheaf::row_dofs(*this);
994 
995  // Postconditions:
996 
997  // Exit:
998 
999  return result;
1000 }
1001 
1002 // PROTECTED MEMBER FUNCTIONS
1003 
1004 // PRIVATE MEMBER FUNCTIONS
1005 
1006 
1007 //==============================================================================
1008 // AT3 FACET OF CLASS AT3_E3
1009 //==============================================================================
1010 
1011 // PUBLIC MEMBER FUNCTIONS
1012 
1013 // PROTECTED MEMBER FUNCTIONS
1014 
1015 // PRIVATE MEMBER FUNCTIONS
1016 
1017 
1018 //==============================================================================
1019 // ATP FACET OF CLASS AT3_E3
1020 //==============================================================================
1021 
1022 // PUBLIC MEMBER FUNCTIONS
1023 
1024 //==============================================================================
1025 // TP FACET OF CLASS AT3_E3
1026 //==============================================================================
1027 
1028 // PUBLIC MEMBER FUNCTIONS
1029 
1030 // PROTECTED MEMBER FUNCTIONS
1031 
1032 // PRIVATE MEMBER FUNCTIONS
1033 
1034 
1035 //==============================================================================
1036 // VD FACET OF CLASS AT3_E3
1037 //==============================================================================
1038 
1039 // PUBLIC MEMBER FUNCTIONS
1040 
1041 // PROTECTED MEMBER FUNCTIONS
1042 
1043 // PRIVATE MEMBER FUNCTIONS
1044 
1045 
1046 //==============================================================================
1047 // TUPLE FACET OF CLASS AT3_E3
1048 //==============================================================================
1049 
1050 // PUBLIC MEMBER FUNCTIONS
1051 
1054 new_tp(int xp, bool xauto_access) const
1055 {
1056  // Preconditions:
1057 
1058  require(precondition_of(e3::new_tp(vector_space(xauto_access), xp)));
1059 
1060  // Body:
1061 
1062  tp* result = e3::new_tp(vector_space(xauto_access), xp);
1063 
1064  // Postconditions:
1065 
1066  ensure(postcondition_of(e3::new_tp(vector_space(xauto_access), xp)));
1067 
1068  // Exit:
1069 
1070  return result;
1071 }
1072 
1075 new_atp(int xp, bool xauto_access) const
1076 {
1077  // Preconditions:
1078 
1079  require(precondition_of(e3::new_atp(vector_space(xauto_access), xp)));
1080 
1081  // Body:
1082 
1083  atp* result = e3::new_atp(vector_space(xauto_access), xp);
1084 
1085  // Postconditions:
1086 
1087  ensure(postcondition_of(e3::new_atp(vector_space(xauto_access), xp)));
1088 
1089  // Exit:
1090 
1091  return result;
1092 }
1093 
1096 new_stp(int xp, bool xauto_access) const
1097 {
1098  // Preconditions:
1099 
1100  require(precondition_of(e3::new_stp(vector_space(xauto_access), xp)));
1101 
1102  // Body:
1103 
1104  stp* result = e3::new_stp(vector_space(xauto_access), xp);
1105 
1106  // Postconditions:
1107 
1108  ensure(postcondition_of(e3::new_stp(vector_space(xauto_access), xp)));
1109 
1110  // Exit:
1111 
1112  return result;
1113 }
1114 
1115 // PROTECTED MEMBER FUNCTIONS
1116 
1117 // PRIVATE MEMBER FUNCTIONS
1118 
1119 
1120 //==============================================================================
1121 // ABSTRACT POSET MEMBER FACET
1122 //==============================================================================
1123 
1124 // PUBLIC MEMBER FUNCTIONS
1125 
1126 const std::string&
1128 class_name() const
1129 {
1130  // Preconditions:
1131 
1132  // Body:
1133 
1134  const string& result = static_class_name();
1135 
1136  // Postconditions:
1137 
1138  ensure(!result.empty());
1139 
1140  // Exit:
1141 
1142  return result;
1143 }
1144 
1145 const std::string&
1148 {
1149  // Preconditions:
1150 
1151  // Body:
1152 
1153  static const string result("at3_e3");
1154 
1155  // Postconditions:
1156 
1157  ensure(!result.empty());
1158 
1159  // Exit:
1160 
1161  return result;
1162 }
1163 
1166 clone() const
1167 {
1168 
1169  // Preconditions:
1170 
1171  // Body:
1172 
1173  // Create new handle of the current class.
1174 
1175  at3_e3* result = new at3_e3();
1176 
1177  // Postconditions:
1178 
1179  ensure(result != 0);
1180  ensure(result->invariant());
1181 
1182  // Exit:
1183 
1184  return result;
1185 
1186 }
1187 
1188 // PROTECTED MEMBER FUNCTIONS
1189 
1190 // PRIVATE MEMBER FUNCTIONS
1191 
1192 
1193 //==============================================================================
1194 // ANY FACET
1195 //==============================================================================
1196 
1197 bool
1199 is_ancestor_of(const any* xother) const
1200 {
1201 
1202  // Preconditions:
1203 
1204  require(xother != 0);
1205 
1206  // Body:
1207 
1208  bool result = dynamic_cast<const at3_e3*>(xother) != 0;
1209 
1210  // Postconditions:
1211 
1212  // Exit:
1213 
1214  return result;
1215 
1216 }
1217 
1218 
1219 bool
1221 invariant() const
1222 {
1223  bool result = true;
1224 
1225  // Body:
1226 
1227  if(invariant_check())
1228  {
1229  // Prevent recursive calls to invariant.
1230 
1231  disable_invariant_check();
1232 
1233  // Must satisfy base class invariant.
1234 
1235  invariance(at3::invariant());
1236 
1237  // Invariances for this class:
1238 
1239  invariance((state_is_read_accessible() ? dd() == 3 : true));
1240 
1241  // Finished, turn invariant checking back on.
1242 
1243  enable_invariant_check();
1244  }
1245 
1246  // Exit:
1247 
1248  return result;
1249 }
1250 
1251 // PROTECTED MEMBER FUNCTIONS
1252 
1253 // PRIVATE MEMBER FUNCTIONS
1254 
1255 
1256 //==============================================================================
1257 // NON-MEMBER FUNCTIONS
1258 //==============================================================================
1259 
1260 #include "SheafSystem/at0.h"
1261 #include "SheafSystem/at2_e3.h"
1262 
1263 void
1265 hook(const at3_e3& x0, const e3& x1, at2_e3& xresult, bool xauto_access)
1266 {
1267  // Preconditions:
1268 
1269  require(x0.state_is_auto_read_accessible(xauto_access));
1270  require(x1.state_is_auto_read_accessible(xauto_access));
1271  require(xresult.state_is_auto_read_write_accessible(xauto_access));
1272 
1273  require(x0.is_p_form(xauto_access) == x1.is_p_form(xauto_access));
1274 
1275  // Body:
1276 
1277  if(xauto_access)
1278  {
1279  x0.get_read_access();
1280  x1.get_read_access();
1281  xresult.get_read_write_access(true);
1282  }
1283 
1284  // The hook operation is essentially a contract operation
1285  // on the first index. In 3d this is pretty simple,
1286  // so we implement it explicitly for efficiency.
1287 
1288  // at3_e3 has just 1 component.
1289 
1290  vd_value_type a = x0.component(0);
1291 
1292  vd_value_type b0 = x1.component(0);
1293  vd_value_type b1 = x1.component(1);
1294  vd_value_type b2 = x1.component(2);
1295 
1296  int lrank = 3;
1297 
1298  vd_value_type lcomp01 = lrank*( a*b2);
1299  vd_value_type lcomp02 = lrank*(-a*b1);
1300  vd_value_type lcomp12 = lrank*(-a*b0);
1301 
1302  xresult.put_component(0, lcomp01);
1303  xresult.put_component(1, lcomp02);
1304  xresult.put_component(2, lcomp12);
1305 
1306 
1307  // Set the variance of the result.
1308 
1309  x0.is_p_form(false) ? xresult.put_is_p_form(false)
1310  : xresult.put_is_p_vector(false);
1311 
1312  if(xauto_access)
1313  {
1314  x0.release_access();
1315  x1.release_access();
1316  xresult.release_access();
1317  }
1318 
1319  // Postconditions:
1320 
1321  ensure(xresult.is_p_form(xauto_access) == x0.is_p_form(xauto_access));
1322 
1323  // Exit:
1324 
1325  return;
1326 
1327 }
1328 
1329 void
1331 hook(const at3_e3_lite& x0, const e3_lite& x1, at2_e3_lite& xresult)
1332 {
1333  // Preconditions:
1334 
1335  // Body:
1336 
1337  // The hook operation is essentially a contract operation
1338  // on the first index. In 3d this is pretty simple,
1339  // so we implement it explicitly for efficiency.
1340 
1341  // at3_e3 has just 1 component.
1342 
1343  vd_value_type a = x0.component(0);
1344 
1345  vd_value_type b0 = x1.component(0);
1346  vd_value_type b1 = x1.component(1);
1347  vd_value_type b2 = x1.component(2);
1348 
1349  int lrank = 3;
1350 
1351  vd_value_type lcomp01 = lrank*( a*b2);
1352  vd_value_type lcomp02 = lrank*(-a*b1);
1353  vd_value_type lcomp12 = lrank*(-a*b0);
1354 
1355  xresult.put_component(0, lcomp01);
1356  xresult.put_component(1, lcomp02);
1357  xresult.put_component(2, lcomp12);
1358 
1359  // Postconditions:
1360 
1362 
1363  //ensure();
1364 
1365  // Exit:
1366 
1367  return;
1368 
1369 }
1370 
1371 void
1373 star(const at3_e3& x0, at0& xresult, bool xauto_access)
1374 {
1375  require(x0.state_is_auto_read_accessible(xauto_access));
1376  require(xresult.state_is_auto_read_write_accessible(xauto_access));
1377 
1378  // Body:
1379 
1380  if(xauto_access)
1381  {
1382  x0.get_read_access();
1383  xresult.get_read_write_access(true);
1384  }
1385 
1386  vd_value_type a123 = x0.component(0);
1387 
1388  xresult.put_component(0, a123);
1389 
1390  // Set the variance of the result.
1391 
1392  // Nothing to do for at0. It's both a p_form and a p_vector.
1393 
1394 
1395  if(xauto_access)
1396  {
1397  x0.release_access();
1398  xresult.release_access();
1399  }
1400 
1401  // Postconditions:
1402 
1403  // Exit:
1404 
1405  return;
1406 }
1407 
1408 void
1410 star(const at3_e3_lite& x0, at0_lite& xresult)
1411 {
1412  // Preconditions:
1413 
1414  // Body:
1415 
1416  vd_value_type a123 = x0.component(0);
1417 
1418  xresult.put_component(0, a123);
1419 
1420  // Postconditions:
1421 
1423 
1424  //ensure();
1425 
1426  // Exit:
1427 
1428  return;
1429 }
1430 
1433 star(const at3_e3_lite& x0)
1434 {
1435  // Preconditions:
1436 
1437  // Body:
1438 
1439  at0_lite* result = new at0_lite();
1440 
1441  star(x0, *result);
1442 
1443  // Postconditions:
1444 
1445  ensure(result != 0);
1446 
1447  // Exit:
1448 
1449  return result;
1450 }
1451 
1452 void
1454 star(const at0& x0, at3_e3& xresult, bool xauto_access)
1455 {
1456  require(x0.state_is_auto_read_accessible(xauto_access));
1457  require(xresult.state_is_auto_read_write_accessible(xauto_access));
1458 
1459  // Body:
1460 
1461  if(xauto_access)
1462  {
1463  x0.get_read_access();
1464  xresult.get_read_write_access(true);
1465  }
1466 
1467  vd_value_type lcomp123 = x0.component(0);
1468 
1469  xresult.put_component(0, lcomp123);
1470 
1471  // Set the variance of the result.
1472 
1473  define_old_variable(bool old_xresult_is_p_form = xresult.is_p_form(false));
1474 
1475  if(xauto_access)
1476  {
1477  x0.release_access();
1478  xresult.release_access();
1479  }
1480 
1481  // Postconditions:
1482 
1483  ensure(xresult.is_p_form(xauto_access) == old_xresult_is_p_form);
1484 
1485  // Exit:
1486 
1487  return;
1488 }
1489 
1490 void
1492 star(const at0_lite& x0, at3_e3_lite& xresult)
1493 {
1494  // Preconditions:
1495 
1496  // Body:
1497 
1498  vd_value_type lcomp123 = x0.component(0);
1499 
1500  xresult.put_component(0, lcomp123);
1501 
1502  // Postconditions:
1503 
1504  ensure(xresult.component(0) == x0.component(0));
1505 
1506  // Exit:
1507 
1508  return;
1509 }
1510 
1511 void
1513 wedge(const at2_e3& x0, const e3& x1, at3_e3& xresult, bool xauto_access)
1514 {
1515  // Preconditions:
1516 
1517  require(x0.state_is_auto_read_accessible(xauto_access));
1518  require(x1.state_is_auto_read_accessible(xauto_access));
1519  require(xresult.state_is_auto_read_write_accessible(xauto_access));
1520 
1521  require(x0.is_p_form(xauto_access) == x1.is_p_form(xauto_access));
1522 
1523  // Body:
1524 
1525  if(xauto_access)
1526  {
1527  x0.get_read_access();
1528  x1.get_read_access();
1529  xresult.get_read_write_access(true);
1530  }
1531 
1532  // The basis order we assume here is "e1^e2, e1^e3, e2^e3"
1533  // Don't confuse "e1, e2, e3" here with fibers with the same name.
1534 
1535  vd_value_type a0 = x0.component(0);
1536  vd_value_type a1 = x0.component(1);
1537  vd_value_type a2 = x0.component(2);
1538 
1539  vd_value_type b0 = x1.component(0);
1540  vd_value_type b1 = x1.component(1);
1541  vd_value_type b2 = x1.component(2);
1542 
1543  vd_value_type lcomp = a0*b0 +a1*b1 + a2*b2;
1544 
1545  xresult.put_component(0, lcomp);
1546 
1547 
1548  // Set the variance of the result.
1549 
1550  x0.is_p_form(false) ? xresult.put_is_p_form(false)
1551  : xresult.put_is_p_vector(false);
1552 
1553 
1554  if(xauto_access)
1555  {
1556  x0.release_access();
1557  x1.release_access();
1558  xresult.release_access();
1559  }
1560 
1561  // Postconditions:
1562 
1563  ensure(xresult.is_p_form(xauto_access) == x0.is_p_form(xauto_access));
1564 
1565  // Exit:
1566 
1567  return;
1568 }
1569 
1570 void
1572 wedge(const at2_e3_lite& x0, const e3_lite& x1, at3_e3_lite& xresult)
1573 {
1574  // Preconditions:
1575 
1576  // Body:
1577 
1578  // The basis order we assume here is "e1^e2, e1^e3, e2^e3"
1579  // Don't confuse "e1, e2, e3" here with fibers with the same name.
1580 
1581  vd_value_type a0 = x0.component(0);
1582  vd_value_type a1 = x0.component(1);
1583  vd_value_type a2 = x0.component(2);
1584 
1585  vd_value_type b0 = x1.component(0);
1586  vd_value_type b1 = x1.component(1);
1587  vd_value_type b2 = x1.component(2);
1588 
1589  vd_value_type lcomp = a0*b0 + a1*b1 *a2*b2;
1590 
1591  xresult.put_component(0, lcomp);
1592 
1593  // Postconditions:
1594 
1595  // Exit:
1596 
1597  return;
1598 }
1599 
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 ...
An antisymmetric rank 3 tensor over an abstract vector space (volatile version).
Definition: at3.h:43
virtual tp * new_tp(int xp, bool xauto_access) const
Virtual constructor for general tensors of degree xp over vector space xvector_space.
Definition: at3_e3.cc:1054
virtual at3_e3 * clone() const
Make a new handle, no state instance of current.
Definition: at3_e3.cc:1166
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
virtual volatile_type * lite_type() const
Virtual conversion to the associated volatile type.
Definition: at3_e3.cc:932
virtual void put_component(int xrow, int xcolumn, value_type xcomp)
Sets value of a component in a specified row and column.
Definition: at2.cc:187
bool full() const
True if both poset name and member name are not empty.
Definition: poset_path.cc:311
virtual void * row_dofs()
The row dofs for this instance (mutable version).
Definition: at3_e3.cc:480
static const poset_path & standard_schema_path()
The path to the standard schema for this class.
Definition: at3_e3.cc:509
virtual const tp_lite & tp_prototype(int xp) const
Prototype for general tensors of degree xp over this vector space.
Definition: at3_e3.cc:277
An antisymmetric tensor of degree p.
Definition: atp.h:190
virtual const std::string & class_name() const
The name of this class.
Definition: at3_e3.cc:1128
void put_is_p_vector(bool xauto_access)
Sets is_p_vector to true; synonym for put_is_contravariant(xauto_access).
Definition: atp.cc:743
Euclidean vector space of dimension 3 (volatile version).
Definition: e3.h:116
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
value_type component() const
Value of (the only) component.
Definition: at0.cc:288
T components[1]
There is only one component (dof) for at3_e3.
Definition: at3_e3.h:102
An antisymmetric rank 3 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: at3_e3.h:120
poset_path path(bool xauto_access=true) const
A path to this component.
An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 3. (persistent version)...
Definition: at2_e3.h:424
bool conforms_to(const schema_poset_member &xother) const
True if the dofs defined by this agree in type and in order with the dofs defined by xother...
The default name space; a poset which contains other posets as members.
virtual const stp_lite & stp_prototype(int xp) const
Prototype for symmetric tensors of degree xp over this vector space.
Definition: at3_e3.cc:319
bool state_is_read_accessible() const
True if this is attached and if the state is accessible for read or access control is disabled...
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...
poset_path vector_space_path() const
The path of the underlying vector space.
Definition: tp_space.cc:365
static void make_standard_schema(namespace_poset &xns)
Creates the standard schema for this class in namespace xns.
Definition: at3_e3.cc:527
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...
bool state_is_auto_read_accessible(bool xauto_access) const
True if the state is auto accessible for read, that is, if the state is already accessible for read o...
A client handle for a general, abstract partially order set.
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
static host_type & standard_host(namespace_type &xns, const std::string &xsuffix, bool xauto_access)
The host with path standard_host_path<at3_e3>(xsuffix). Returns the host if it already exists...
Definition: at3_e3.cc:611
STL namespace.
value_type component(int xindex) const
The xindex-th component.
Definition: vd.cc:209
bool invariant() const
Class invariant.
Definition: at3_e3.cc:452
virtual value_type component(int xi, int xj, int xk) const
The value of component with indices xi, xj, xk.
Definition: at3.cc:770
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: at3_e3.cc:1199
virtual void get_read_access() const
Get read access to the state associated with this.
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.
Euclidean vector space of dimension 3 (persistent version).
Definition: e3.h:467
T::row_dofs_type & row_dofs(T &x0)
The row dofs pod type for x0 (mutable version).
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
at3_e3_lite & operator=(const at3_e3_lite &xother)
Assignment operator.
Definition: at3_e3.cc:77
bool invariant() const
Class invariant.
Definition: at3_e3.cc:1221
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...
virtual ~at3_e3_lite()
Destructor.
Definition: at3_e3.cc:99
Abstract base class with useful features for all volatile objects.
Definition: any_lite.h:48
An antisymmetric rank 3 tensor over a 3D Euclidean vector space.
Definition: at3_e3.h:372
Abstract base class with useful features for all objects.
Definition: any.h:39
virtual value_type component(int xi, int xj, int xk) const
The value of component with indices xi, xj, xk.
Definition: at3.cc:189
SHEAF_DLL_SPEC void wedge(const e2 &x0, const e2 &x1, at2_e2 &xresult, bool xauto_access)
The exterior (wedge) product of two antisymmetric tensors (pre-allocated version for persistent types...
Definition: at2_e2.cc:1779
SHEAF_DLL_SPEC void hook(const e2 &x0, const e2 &x1, at0 &xresult, bool xauto_access)
The interior (hook) product of two antisymmetric tensors (pre-allocated version for persistent types)...
Definition: at2_e2.cc:1328
virtual schema_poset_member & schema()
The schema for this poset (mutable version).
virtual const std::string & class_name() const
The name of this class.
Definition: at3_e3.cc:362
virtual atp * new_atp(int xp, bool xauto_access) const
Virtual constructor for antisymmetric tensors of degree xp over vector space xvector_space.
Definition: at3_e3.cc:1075
An abstract antisymmetric tensor space of degree p.
Definition: atp_space.h:42
static const std::string & static_class_name()
The name of this class.
Definition: at3_e3.cc:381
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 void put_component(int xi, int xj, int xk, value_type xvalue)
Sets the component with indices xi, xj, xk to xvalue.
Definition: at3.cc:228
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)
at3_e3 & operator=(const row_dofs_type &xrdt)
Assignment to an instance of the associated row dofs type.
Definition: at3_e3.cc:835
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
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
bool is_p_form(bool xauto_access) const
True if this is a p-form; synonym for is_covariant(xauto_access).
Definition: atp.cc:677
Antisymetric tensor of degree 0 (volatile version).
Definition: at0.h:127
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
virtual stp * new_stp(int xp, bool xauto_access) const
Virtual constructor for symmetric tensors of degree xp over vector space xvector_space.
Definition: at3_e3.cc:1096
virtual value_type component(int xindex) const
The value of the xi-th component.
Definition: vd.cc:1115
at3_e3_lite()
Default constructor.
Definition: at3_e3.cc:45
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...
virtual bool is_ancestor_of(const any_lite &xother) const
Conformance test; true if other conforms to this.
Definition: at3_e3.cc:433
row_dofs_type _row_dofs
Row_dofs_type.
Definition: at3_e3.h:196
A general tensor of degree p over an abstract vector space (volatile version). Volatile version does ...
Definition: tp.h:59
at3_e3()
Default constructor.
Definition: at3_e3.cc:678
bool contains_poset(pod_index_type xhub_id, bool xauto_access=true) const
True if this contains a poset with hub id xhub_id..
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.
static const std::string & static_class_name()
The name of this class.
Definition: at3_e3.cc:1147
poset_path scalar_space_path() const
The path of the underlying space of scalars.
Definition: vd_space.cc:250
virtual const volatile_type & lite_prototype() const
Virtual constructor for the associated volatile type.
Definition: at3_e3.cc:914
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...
An abstract vector space viewed as an antisymmetric tensor space of degree 1.
Definition: at1_space.h:42
virtual void put_component(value_type xcomp)
Set value of (the only) component to xcomp.
Definition: at0.cc:270
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
static host_type & new_host(namespace_type &xns, const poset_path &xhost_path, const poset_path &xschema_path, const poset_path &xvector_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: at3_e3.cc:559
virtual void put_components(const value_type &xcomp)
Set the value of the component to xcomp.
Definition: at3_e3.cc:195
int dd() const
The dimension of the underlying ("domain") vector space.
Definition: tp_space.cc:317
virtual int dd() const
Dimension of the underlying vector space.
Definition: at3_e3.cc:246
An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: at2_e3.h:142
virtual void put_component(int xi, int xj, int xk, value_type xvalue)
Sets the component with indices xi, xj, xk to xvalue.
Definition: at3.cc:842
~at3_e3()
Destructor.
Definition: at3_e3.cc:901
virtual value_type component(int xrow, int xcolumn) const
The value of the component in a specified row and column.
Definition: at2.cc:148
An abstract client handle for a member of a poset.
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
virtual const atp_lite & atp_prototype(int xp) const
Prototype for antisymmetric tensors of degree xp over this vector space.
Definition: at3_e3.cc:298
virtual at3_e3_lite * clone() const
Virtual constructor, makes a new instance of the same type as this.
Definition: at3_e3.cc:400
value_type component(int xrow, int xcolumn) const
The component with row index xrow and column index xcolumn.
Definition: at2.cc:787
virtual void put_component(int xindex, value_type xvalue)
Sets the value of the xindex-th component to xvalue.
Definition: vd.cc:1169
void put_is_p_form(bool xauto_access)
Sets is_p_form to true; synonym for put_is_covariant(xauto_access).
Definition: atp.cc:699
void put_component(int xrow, int xcolumn, value_type xvalue)
Sets the component with row index xrow and column index xcolumn to xvalue.
Definition: at2.cc:851
A symmetric tensor of degree p over an abstract vector space (volatile version).
Definition: stp.h:44
Namespace for the fiber_bundles component of the sheaf system.
SHEAF_DLL_SPEC void star(const at2_e2 &x0, at0 &xresult, bool xauto_access)
The Hodge star operator for antisymmetric tensors (pre-allocated version persistent types)...
Definition: at2_e2.cc:1518
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...
A client handle for a poset member which has been prepared for use as a schema.
virtual void put_components(dof_type xcomp)
Sets the value of the component to xcomp.
Definition: at3_e3.cc:950
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
SHEAF_DLL_SPEC bool isunordered_or_equals(float x1, float x2)
True if isunordered(x1, x2) or x1 == x2.
Definition: sheaf.cc:102