SheafSystem  0.0.0.0
jcb.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/jcb.h"
22 
23 #include "SheafSystem/abstract_poset_member.impl.h"
24 #include "SheafSystem/assert_contract.h"
25 #include "SheafSystem/at1.h"
26 #include "SheafSystem/at1_space.h"
27 #include "SheafSystem/jcb_space.h"
28 #include "SheafSystem/fiber_bundles_namespace.h"
29 #include "SheafSystem/schema_poset_member.h"
30 #include "SheafSystem/wsv_block.h"
31 
32 using namespace std;
33 using namespace fiber_bundle; // Workaround for MS C++ bug.
34 
35 //==============================================================================
36 // CLASS JCB_LITE
37 //==============================================================================
38 
39 //==============================================================================
40 // JACOBIAN (JCB) FACET OF CLASS JCB_LITE
41 //==============================================================================
42 
43 // PUBLIC MEMBER FUNCTIONS
44 
47 {
48  // Preconditions:
49 
50  // Body:
51 
52  // Postconditions:
53 
54  ensure(invariant());
55 
56  // Exit:
57 }
58 
60 jcb_lite(const jcb_lite& xother)
61 {
62  // Preconditions:
63 
64  // Body:
65 
66  // Postconditions:
67 
68  ensure(invariant());
69 
70  // Exit:
71 }
72 
75 operator=(const jcb_lite& xother)
76 {
77  // Preconditions:
78 
79 
80  // Body:
81 
82 
83  // Postconditions:
84 
85  ensure(invariant());
86 
87  // Exit:
88 
89  return *this;
90 }
91 
94 {
95  // Preconditions:
96 
97 
98  // Body:
99 
100 
101  // Postconditions:
102 
103  // Exit:
104 
105 }
106 
108 jcb_lite(const row_dofs_type& xrow_dofs)
109 {
110  // Preconditions:
111 
112  // Body:
113 
114  *this = xrow_dofs;
115 
116  // Postconditions:
117 
118  ensure(invariant());
119 
120  // Exit:
121 }
122 
125 operator=(const row_dofs_type& xrow_dofs)
126 {
127  // Preconditions:
128 
129  // Body:
130 
131  vd_lite::operator=(xrow_dofs);
132 
133  // Postconditions:
134 
135  postcondition_of(vd_lite::operator=(xrow_dofs));
136 
137  // Exit:
138 
139  return *this;
140 
141 }
142 
143 int
145 dd() const
146 {
147  // Preconditions:
148 
149  // Body:
150 
151  int result = 0; // Just to silence compiler.
152 
153  // Postconditions:
154 
155  ensure(invariant());
156  ensure(result == 0);
157 
158  // Exit:
159 
160  return result;
161 }
162 
163 int
165 dr() const
166 {
167  // Preconditions:
168 
169  // Body:
170 
171  int result = 0; // Just to silence compiler.
172 
173  // Postconditions:
174 
175  ensure(invariant());
176  ensure(result == 0);
177 
178  // Exit:
179 
180  return result;
181 }
182 
183 
186 table_dofs() const
187 {
188  // Preconditions:
189 
190  // Body:
191 
192  int lfactor_ct = factor_ct();
193  int ld = d();
194 
196 
197  char* lscalar_space_path = new char[1];
198  lscalar_space_path[0] = 0;
199 
200  int ldd = dd();
201 
202  char* ldomain_path = new char[1];
203  ldomain_path[0] = 0;
204 
205  char* lrange_path = new char[1];
206  lrange_path[0] = 0;
207 
208  int ldr = dr();
209 
210  table_dofs_type result;
211 
212  result.factor_ct = lfactor_ct;
213  result.d = ld;
214  result.scalar_space_path = lscalar_space_path;
215  result.dd = ldd;
216  result.domain_path = ldomain_path;
217  result.range_path = lrange_path;
218  result.dr = ldr;
219 
220  // Postconditions:
221 
222  // Exit:
223 
224  return result;
225 }
226 
229 component(int xrow, int xcolumn) const
230 {
231  // Preconditions:
232 
233  require(xrow >= 0 && xrow < dr());
234  require(xcolumn >= 0 && xcolumn < dd());
235 
236  // Body:
237 
238  value_type result = component(index_for_row_column(xrow, xcolumn));
239 
240  // Postconditions:
241 
242  ensure(invariant());
243 
244  // Exit:
245 
246  return result;
247 }
248 
249 void
251 put_component(int xrow, int xcolumn, value_type xcomp)
252 {
253  // Preconditions:
254 
255  require(xrow >= 0 && xrow < dr());
256  require(xcolumn >= 0 && xcolumn < dd());
257 
258  // Body:
259 
260  put_component(index_for_row_column(xrow, xcolumn), xcomp);
261 
262  // Postconditions:
263 
264  ensure(invariant());
265  ensure(isunordered_or_equals(component(index_for_row_column(xrow, xcolumn)), xcomp));
266 
267  // Exit:
268 
269  return;
270 }
271 
272 int
274 index_for_row_column(int xrow, int xcolumn) const
275 {
276  // Preconditions:
277 
278  require(0 <= xrow && xrow < dr());
279  require(0 <= xcolumn && xcolumn < dd());
280 
281  // Body:
282 
283  // Convert (xrow, xcolumn) into an index into linear component storage.
284 
285  int result = xrow*dd() + xcolumn;
286 
287  // Postconditions:
288 
289  ensure(invariant());
290  ensure(result >= 0);
291  ensure(result < dr()*dd());
292 
293  // Exit:
294 
295  return result;
296 }
297 
298 // PROTECTED MEMBER FUNCTIONS
299 
300 // PRIVATE MEMBER FUNCTIONS
301 
302 
303 //==============================================================================
304 // VECTOR ALGEBRA (VD) FACET OF CLASS JCB_LITE
305 //==============================================================================
306 
307 // PUBLIC MEMBER FUNCTIONS
308 
309 int
311 d() const
312 {
313  // Preconditions:
314 
315  // Body:
316 
317  int result = dd()*dr();
318 
319  // Postconditions:
320 
321  ensure(invariant());
322  ensure(result==dd()*dr());
323 
324  // Exit:
325 
326  return result;
327 }
328 
329 // PROTECTED MEMBER FUNCTIONS
330 
331 // PRIVATE MEMBER FUNCTIONS
332 
333 
334 //==============================================================================
335 // CARTESIAN ALGEBRA (TUPLE) FACET OF CLASS JCB_LITE
336 //==============================================================================
337 
338 // PUBLIC MEMBER FUNCTIONS
339 
340 // PROTECTED MEMBER FUNCTIONS
341 
342 // PRIVATE MEMBER FUNCTIONS
343 
344 
345 //==============================================================================
346 // ABSTRACT POSET MEMBER FACET OF CLASS JCB_LITE
347 //==============================================================================
348 
349 // PUBLIC MEMBER FUNCTIONS
350 
351 const std::string&
353 class_name() const
354 {
355  // Preconditions:
356 
357  // Body:
358 
359  const string& result = static_class_name();
360 
361  // Postconditions:
362 
363  ensure(!result.empty());
364 
365  // Exit:
366 
367  return result;
368 }
369 
370 const std::string&
373 {
374  // Preconditions:
375 
376  // Body:
377 
378  static const string result("jcb_lite");
379 
380  // Postconditions:
381 
382  ensure(!result.empty());
383 
384  // Exit:
385 
386  return result;
387 }
388 
391 clone() const
392 {
393  jcb_lite* result = 0;
394 
395  // Preconditions:
396 
397  // Body:
398 
399  result = new jcb_lite();
400 
401  // Postconditions:
402 
403  ensure(result != 0);
404  ensure(is_same_type(*result));
405 
406  // Exit:
407 
408  return result;
409 }
410 
411 // PROTECTED MEMBER FUNCTIONS
412 
413 // PRIVATE MEMBER FUNCTIONS
414 
415 
416 //==============================================================================
417 // ANY FACET OF CLASS JCB_LITE
418 //==============================================================================
419 
420 // PUBLIC MEMBER FUNCTIONS
421 
422 bool
424 is_ancestor_of(const any_lite& xother) const
425 {
426  // Preconditions:
427 
428  require(&xother != 0);
429 
430  // Body:
431 
432  // True if other conforms to this.
433 
434  bool result = dynamic_cast<const vd_lite*>(&xother) != 0;
435 
436  // Postconditions:
437 
438  return result;
439 }
440 
441 bool
443 invariant() const
444 {
445  bool result = true;
446 
447  if(invariant_check())
448  {
449  // Prevent recursive calls to invariant.
450 
451  disable_invariant_check();
452 
453  // Must satisfy base class invariant.
454 
455  invariance(vd_lite::invariant());
456 
457  // Invariances for this class:
458 
459  // Finished, turn invariant checking back on.
460 
461  enable_invariant_check();
462  }
463 
464  // Exit
465 
466  return result;
467 }
468 
469 // PROTECTED MEMBER FUNCTIONS
470 
471 // PRIVATE MEMBER FUNCTIONS
472 
473 
474 //==============================================================================
475 // CLASS JCB
476 //==============================================================================
477 
478 // ===========================================================
479 // HOST FACTORY FACET
480 // ===========================================================
481 
482 // PUBLIC MEMBER FUNCTIONS
483 
484 const sheaf::poset_path&
487 {
488  // Preconditions:
489 
490 
491  // Body:
492 
493  static const poset_path result(standard_schema_poset_name(), "jcb_schema");
494 
495  // Postconditions:
496 
497  ensure(result.full());
498  ensure(result.poset_name() == standard_schema_poset_name());
499 
500  // Exit:
501 
502  return result;
503 }
504 
505 void
508 {
509  // Preconditions:
510 
511  require(xns.state_is_read_write_accessible());
512  require(xns.contains_poset(standard_schema_poset_name()));
513  require(!xns.contains_poset_member(standard_schema_path()));
514 
515  // Body:
516 
517  // Order has conform to order in dof id space of top.
518 
519  string lmember_names;
520  lmember_names += "dd INT true";
521  lmember_names += " domain_path C_STRING true";
522  lmember_names += " range_path C_STRING true";
523  lmember_names += " dr INT true";
524 
525  schema_poset_member lschema(xns,
526  standard_schema_path().member_name(),
527  vd::standard_schema_path(),
528  lmember_names,
529  false);
530 
531  lschema.detach_from_state();
532 
533  // Postconditions:
534 
535  ensure(xns.contains_poset_member(standard_schema_path()));
536 
537  // Exit:
538 
539  return;
540 }
541 
545  const poset_path& xhost_path,
546  const poset_path& xschema_path,
547  const poset_path& xdomain_path,
548  const poset_path& xrange_path,
549  bool xauto_access)
550 {
551  // cout << endl << "Entering jcb::new_host." << endl;
552 
553  // Preconditions:
554 
555  require(xns.state_is_auto_read_write_accessible(xauto_access));
556 
557  require(!xhost_path.empty());
558  require(!xns.contains_path(xhost_path, xauto_access));
559 
560  require(xschema_path.full());
561  require(xns.path_is_auto_read_accessible(xschema_path, xauto_access));
562  require(schema_poset_member::conforms_to(xns, xschema_path, standard_schema_path()));
563 
564  require(xns.path_is_auto_read_accessible<domain_type::host_type>(xdomain_path, xauto_access));
565  require(xns.path_is_auto_read_accessible<range_type::host_type>(xrange_path, xauto_access));
566 
567  require(host_type::d(xns, xschema_path, xauto_access) == host_type::d(xns, xdomain_path, xrange_path, xauto_access));
568 
569  require(xns.member_poset<domain_type::host_type>(xdomain_path, xauto_access).scalar_space_path(xauto_access) ==
570  xns.member_poset<range_type::host_type>(xrange_path, xauto_access).scalar_space_path(xauto_access));
571 
572  // Body:
573 
574  host_type& result =
575  host_type::new_table(xns, xhost_path, xschema_path, xdomain_path, xrange_path, xauto_access);
576 
577  // Postconditions:
578 
579  ensure(xns.owns(result, xauto_access));
580  ensure(result.path(true) == xhost_path);
581  ensure(result.state_is_not_read_accessible());
582  ensure(result.schema(true).path(xauto_access) == xschema_path);
583 
584  ensure(result.factor_ct(true) == result.d(true));
585  ensure(result.d(true) == host_type::d(xns, xschema_path, xauto_access));
586 
587  ensure(result.domain_path(true) == xdomain_path);
588  ensure(result.dd(true) == xns.member_poset<domain_type::host_type>(xdomain_path, xauto_access).d());
589 
590  ensure(result.range_path(true) == xrange_path);
591  ensure(result.dr(true) == xns.member_poset<range_type::host_type>(xrange_path, xauto_access).d());
592 
593  ensure(result.scalar_space_path(true) ==
594  xns.member_poset<domain_type::host_type>(xdomain_path, xauto_access).scalar_space_path(xauto_access) );
595  ensure(result.scalar_space_path(true) ==
596  xns.member_poset<range_type::host_type>(xrange_path, xauto_access).scalar_space_path(xauto_access) );
597 
598  // Exit:
599 
600  // cout << "Leaving jcb::new_host." << endl;
601  return result;
602 }
603 
604 
605 // PROTECTED MEMBER FUNCTIONS
606 
607 // PRIVATE MEMBER FUNCTIONS
608 
609 
610 //==============================================================================
611 // JCB FACET OF CLASS JCB
612 //==============================================================================
613 
614 // PUBLIC MEMBER FUNCTIONS
615 
618 {
619 
620  // Preconditions:
621 
622  // Body:
623 
624  // Postconditions:
625 
626  ensure(invariant());
627 }
628 
630 jcb(const poset_state_handle* xhost, pod_index_type xhub_id)
631 {
632  // Preconditions:
633 
634  require(xhost != 0);
635  require(xhost->state_is_read_accessible());
636  require(xhost->contains_member(xhub_id));
637 
638  // Body:
639 
640  attach_to_state(xhost, xhub_id);
641 
642  // Postconditions:
643 
644  ensure(invariant());
645  // ensure(host() == xhost);
646  ensure(index() == xhub_id);
647  ensure(is_attached());
648 
649 }
650 
652 jcb(const poset_state_handle* xhost, const scoped_index& xid)
653 {
654  // Preconditions:
655 
656  require(xhost != 0);
657  require(xhost->state_is_read_accessible());
658  require(xhost->contains_member(xid));
659 
660  // Body:
661 
662  attach_to_state(xhost, xid.hub_pod());
663 
664  // Postconditions:
665 
666  ensure(invariant());
667  // ensure(host() == xhost);
668  ensure(index() ==~ xid);
669  ensure(is_attached());
670 }
671 
673 jcb(const poset_state_handle* xhost, const std::string& xname)
674 {
675 
676  // Preconditions:
677 
678  require(xhost != 0);
679  require(xhost->state_is_read_accessible());
680  require(!xname.empty());
681  require(xhost->contains_member(xname));
682 
683  // Body:
684 
685  attach_to_state(xhost, xname);
686 
687  // Postconditions:
688 
689  ensure(invariant());
690  // ensure(host() == xhost);
691  ensure(name() == xname);
692  ensure(is_attached());
693 
694 }
695 
698 {
699 
700  // Preconditions:
701 
702  require(xother != 0);
703 
704  // Body:
705 
706  attach_to_state(xother);
707 
708  // Postconditions:
709 
710  ensure(invariant());
711  ensure(is_attached());
712  ensure(is_same_state(xother));
713 
714 }
715 
717 jcb(poset_state_handle* xhost, bool xauto_access)
718 {
719 
720  // Preconditions:
721 
722  require(precondition_of(new_jim_state(xhost, 0, false, xauto_access)));
723 
724  // Body:
725 
726  new_jim_state(xhost, 0, false, xauto_access);
727 
728  // Postconditions:
729 
730  ensure(postcondition_of(new_jim_state(xhost, 0, false, xauto_access)));
731 
732  // Exit:
733 
734  return;
735 }
736 
741 {
742  // Preconditions:
743 
744  require(is_ancestor_of(&xother));
745  require(precondition_of(attach_to_state(&xother)));
746 
747  // Body:
748 
749  attach_to_state(&xother);
750 
751  // Postconditions:
752 
753  ensure(postcondition_of(attach_to_state(&xother)));
754 
755  // Exit:
756 
757  return *this;
758 }
759 
763 operator=(const jcb& xother)
764 {
765  // Preconditions:
766 
767  require(precondition_of(attach_to_state(&xother)));
768 
769  // Body:
770 
771  attach_to_state(&xother);
772 
773  // Postconditions:
774 
775  ensure(postcondition_of(attach_to_state(&xother)));
776 
777  // Exit:
778 
779  return *this;
780 }
781 
784 {
785 
786  // Preconditions:
787 
788  // Body:
789 
790  // Postconditions:
791 
792 }
793 
797 {
798  // Preconditions:
799 
800  // Body:
801 
802  static const volatile_type result;
803 
804  // Postconditions:
805 
806  // Exit:
807 
808  return result;
809 }
810 
814 lite_type() const
815 {
816  // Preconditions:
817 
818  // Body:
819 
820  volatile_type* result = new volatile_type(sheaf::row_dofs(*this));
821 
822  // Postconditions:
823 
824  // Exit:
825 
826  return result;
827 }
828 
829 int
831 dd() const
832 {
833  // Preconditions:
834 
835  require(state_is_read_accessible());
836 
837  // Body:
838 
839  int result = host()->dd();
840 
841  // Postconditions:
842 
843  ensure(result >= 0);
844 
845  // Exit:
846 
847  return result;
848 }
849 
850 int
852 dd(bool xauto_access) const
853 {
854  // Preconditions:
855 
856  require(state_is_auto_read_accessible(xauto_access));
857 
858  // Body:
859 
860  int result = host()->dd(xauto_access);
861 
862  // Postconditions:
863 
864  ensure(result >= 0);
865 
866  // Exit:
867 
868  return result;
869 }
870 
873 domain_path() const
874 {
875  // Preconditions:
876 
877  require(state_is_read_accessible());
878 
879  // Body:
880 
881  poset_path result(host()->domain_path());
882 
883  // Postconditions:
884 
885  ensure(!result.empty());
886 
887  // Exit:
888 
889  return result;
890 }
891 
894 domain_path(bool xauto_access) const
895 {
896  // Preconditions:
897 
898  require(state_is_auto_read_accessible(xauto_access));
899 
900  // Body:
901 
902  poset_path result(host()->domain_path(xauto_access));
903 
904  // Postconditions:
905 
906  ensure(!result.empty());
907 
908  // Exit:
909 
910  return result;
911 }
912 
913 int
915 dr() const
916 {
917  // Preconditions:
918 
919  require(state_is_read_accessible());
920 
921  // Body:
922 
923  int result = host()->dr();
924 
925  // Postconditions:
926 
927  ensure(result >= 0);
928 
929  // Exit:
930 
931  return result;
932 }
933 
934 int
936 dr(bool xauto_access) const
937 {
938  // Preconditions:
939 
940  require(state_is_auto_read_accessible(xauto_access));
941 
942  // Body:
943 
944  int result = host()->dr(xauto_access);
945 
946  // Postconditions:
947 
948  ensure(result >= 0);
949 
950  // Exit:
951 
952  return result;
953 }
954 
957 range_path() const
958 {
959  // Preconditions:
960 
961  require(state_is_read_accessible());
962 
963  // Body:
964 
965  poset_path result(host()->range_path());
966 
967  // Postconditions:
968 
969  ensure(!result.empty());
970 
971  // Exit:
972 
973  return result;
974 }
975 
978 range_path(bool xauto_access) const
979 {
980  // Preconditions:
981 
982  require(state_is_auto_read_accessible(xauto_access));
983 
984  // Body:
985 
986  poset_path result(host()->range_path(xauto_access));
987 
988  // Postconditions:
989 
990  ensure(!result.empty());
991 
992  // Exit:
993 
994  return result;
995 }
996 
997 int
999 index_for_row_column(int xrow, int xcolumn) const
1000 {
1001  // Preconditions:
1002 
1003  require(state_is_read_accessible());
1004  require(0 <= xrow && xrow < dr());
1005  require(0 <= xcolumn && xcolumn < dd());
1006 
1007  // Body:
1008 
1009  // Convert (xrow, xcolumn) into an index into linear component storage.
1010 
1011  int result = xrow*dd() + xcolumn;
1012 
1013  // Postconditions:
1014 
1015  //ensure(invariant());
1016  ensure(result >= 0);
1017  ensure(result < dr()*dd());
1018 
1019  // Exit:
1020 
1021  return result;
1022 }
1023 
1024 // PROTECTED MEMBER FUNCTIONS
1025 
1026 // PRIVATE MEMBER FUNCTIONS
1027 
1028 
1029 //==============================================================================
1030 // VD FACET OF CLASS JCB
1031 //==============================================================================
1032 
1033 // PUBLIC MEMBER FUNCTIONS
1034 
1037 component(int xrow, int xcolumn) const
1038 {
1039  // Preconditions:
1040 
1041  require(state_is_read_accessible());
1042  require((0 <= xrow) && (xrow < dr()));
1043  require((0 <= xcolumn) && (xcolumn < dd()));
1044 
1045  // Body:
1046 
1047  value_type result = component(index_for_row_column(xrow, xcolumn));
1048 
1049  // Postconditions:
1050 
1051  ensure(invariant());
1052 
1053  // Exit:
1054 
1055  return result;
1056 }
1057 
1060 component(int xrow, int xcolumn, bool xauto_access) const
1061 {
1062  // Preconditions:
1063 
1064  require(state_is_auto_read_accessible(xauto_access));
1065  require((0 <= xrow) && (xrow < dr(xauto_access)));
1066  require((0 <= xcolumn) && (xcolumn < dd(xauto_access)));
1067 
1068  // Body:
1069 
1070  if(xauto_access)
1071  {
1072  get_read_access();
1073  }
1074 
1075  value_type result = component(xrow, xcolumn);
1076 
1077  if(xauto_access)
1078  {
1079  release_access();
1080  }
1081 
1082  // Postconditions:
1083 
1084  ensure(invariant());
1085 
1086  // Exit:
1087 
1088  return result;
1089 }
1090 
1091 void
1093 put_component(int xrow, int xcolumn, value_type xvalue)
1094 {
1095 
1096  // Preconditions:
1097 
1098  require(state_is_read_write_accessible());
1099  require((0 <= xrow) && (xrow < dr()));
1100  require((0 <= xcolumn) && (xcolumn < dd()));
1101 
1102  // Body:
1103 
1104  put_component(index_for_row_column(xrow, xcolumn), xvalue);
1105 
1106  // Postconditions:
1107 
1108  ensure(invariant());
1109  ensure(isunordered_or_equals(component(xrow, xcolumn), xvalue));
1110 
1111  // Exit:
1112 
1113  return;
1114 }
1115 
1116 void
1118 put_component(int xrow, int xcolumn, value_type xvalue, bool xauto_access)
1119 {
1120 
1121  // Preconditions:
1122 
1123  require(state_is_auto_read_write_accessible(xauto_access));
1124  require((0 <= xrow) && (xrow < dr(xauto_access)));
1125  require((0 <= xcolumn) && (xcolumn < dd(xauto_access)));
1126 
1127  // Body:
1128 
1129  if(xauto_access)
1130  {
1131  get_read_write_access(true);
1132  }
1133 
1134  put_component(index_for_row_column(xrow, xcolumn), xvalue);
1135 
1136  if(xauto_access)
1137  {
1138  release_access();
1139  }
1140 
1141  // Postconditions:
1142 
1143  ensure(invariant());
1144  ensure(isunordered_or_equals(component(xrow, xcolumn), xvalue));
1145 
1146  // Exit:
1147 
1148  return;
1149 }
1150 
1151 // PROTECTED MEMBER FUNCTIONS
1152 
1153 // PRIVATE MEMBER FUNCTIONS
1154 
1155 
1156 //==============================================================================
1157 // TUPLE FACET OF CLASS JCB
1158 //==============================================================================
1159 
1160 // PUBLIC MEMBER FUNCTIONS
1161 
1162 // PROTECTED MEMBER FUNCTIONS
1163 
1164 // PRIVATE MEMBER FUNCTIONS
1165 
1166 
1167 //==============================================================================
1168 // ABSTRACT POSET MEMBER FACET OF CLASS JCB
1169 //==============================================================================
1170 
1171 // PUBLIC MEMBER FUNCTIONS
1172 
1173 const std::string&
1175 class_name() const
1176 {
1177  // Preconditions:
1178 
1179  // Body:
1180 
1181  const string& result = static_class_name();
1182 
1183  // Postconditions:
1184 
1185  ensure(!result.empty());
1186 
1187  // Exit:
1188 
1189  return result;
1190 }
1191 
1192 const std::string&
1195 {
1196  // Preconditions:
1197 
1198  // Body:
1199 
1200  static const string result("jcb");
1201 
1202  // Postconditions:
1203 
1204  ensure(!result.empty());
1205 
1206  // Exit:
1207 
1208  return result;
1209 }
1210 
1211 // PROTECTED MEMBER FUNCTIONS
1212 
1213 // PRIVATE MEMBER FUNCTIONS
1214 
1215 
1216 // ===========================================================
1217 // POSET_COMPONENT FACET
1218 // ===========================================================
1219 
1220 // PUBLIC MEMBER FUNCTIONS
1221 
1224 host() const
1225 {
1226  return reinterpret_cast<host_type*>(_host);
1227 }
1228 
1229 bool
1232 {
1233  return dynamic_cast<const host_type*>(xother) != 0;
1234 }
1235 
1236 // PROTECTED MEMBER FUNCTIONS
1237 
1238 // PRIVATE MEMBER FUNCTIONS
1239 
1240 
1241 
1242 //==============================================================================
1243 // ANY FACET OF CLASS JCB
1244 //==============================================================================
1245 
1246 // PUBLIC MEMBER FUNCTIONS
1247 
1248 bool
1250 is_ancestor_of(const any* xother) const
1251 {
1252 
1253  // Preconditions:
1254 
1255  require(xother != 0);
1256 
1257  // Body:
1258 
1259  // If xother may be dynamically cast to the type of this then this is an
1260  // ancestor of other.
1261 
1262  bool result = dynamic_cast<const jcb*>(xother) != 0;
1263 
1264  // Postconditions:
1265 
1266  // ensure(invariant());
1267 
1268  // Exit:
1269 
1270  return result;
1271 
1272 }
1273 
1276 clone() const
1277 {
1278 
1279  // Preconditions:
1280 
1281  jcb* result = 0;
1282 
1283  // Body:
1284 
1285  result = new jcb();
1286 
1287  // Postconditions:
1288 
1289  ensure(result != 0);
1290  ensure(result->invariant());
1291 
1292  // Exit:
1293 
1294  return result;
1295 
1296 }
1297 
1298 bool
1300 invariant() const
1301 {
1302  bool result = true;
1303 
1304  // Preconditions:
1305 
1306  // Body:
1307 
1308  // Must satisfy base class invariant.
1309 
1310  invariance(vd::invariant());
1311 
1312  if (invariant_check())
1313  {
1314  // Prevent recursive calls to invariant.
1315 
1316  disable_invariant_check();
1317 
1318  invariance((is_attached() ? (d() == dd() * dr()) : true));
1319 
1320  // Finished, turn invariant checking back on.
1321 
1322  enable_invariant_check();
1323  }
1324 
1325  // Postconditions:
1326 
1327  ensure(is_derived_query);
1328 
1329  // Exit:
1330 
1331  return result;
1332 }
1333 
1334 // PROTECTED MEMBER FUNCTIONS
1335 
1336 // PRIVATE MEMBER FUNCTIONS
1337 
1338 
1339 //==============================================================================
1340 // NON-MEMBER FUNCTIONS
1341 //==============================================================================
1342 
1344 std::ostream&
1346 operator<<(std::ostream& xos, jcb_lite::table_dofs_type& xt)
1347 {
1348  xos << " " << xt.factor_ct
1349  << " " << xt.d
1350  << " " << xt.dd
1351  << " " << xt.domain_path
1352  << " " << xt.dr
1353  << " " << xt.range_path;
1354 
1355  return xos;
1356 }
1357 
1358 //==============================================================================
1359 // JCB FACET:
1360 //==============================================================================
1361 
1362 #include "SheafSystem/error_message.h"
1363 #include "SheafSystem/at1.h"
1364 #include "SheafSystem/e1.h"
1365 #include "SheafSystem/e2.h"
1366 #include "SheafSystem/e3.h"
1367 #include "SheafSystem/jcb_e13.h"
1368 #include "SheafSystem/jcb_e23.h"
1369 #include "SheafSystem/jcb_e33.h"
1370 
1372 void
1374 push(const jcb& xjcb, const at1& xvector, at1& xresult, bool xauto_access)
1375 {
1376  // Preconditions:
1377 
1378  require(xjcb.state_is_auto_read_accessible(xauto_access));
1379  require(xvector.state_is_auto_read_accessible(xauto_access));
1380  require(xresult.state_is_auto_read_write_accessible(xauto_access));
1381  require(xvector.d(xauto_access) == xjcb.dd(xauto_access));
1382  require(xresult.d(xauto_access) == xjcb.dr(xauto_access));
1383  require(xvector.is_contravariant(0, xauto_access)); // !is_dual
1384  require(xresult.is_contravariant(0, xauto_access)); // !is_dual
1385 
1386  // Body:
1387 
1388  // jcb_e13:
1389  // xvector == e1
1390  // xresult == e3
1391 
1392  // jcb_e23:
1393  // xvector == e2
1394  // xresult == e3
1395 
1396  // jcb_e33:
1397  // xvector == e3
1398  // xresult == e3
1399 
1400  const jcb_e13* jcb_e13_xjcb = dynamic_cast<const jcb_e13*>(&xjcb);
1401  const jcb_e23* jcb_e23_xjcb = dynamic_cast<const jcb_e23*>(&xjcb);
1402  const jcb_e33* jcb_e33_xjcb = dynamic_cast<const jcb_e33*>(&xjcb);
1403 
1404  const e1* e1_xvector = dynamic_cast<const e1*>(&xvector);
1405  const e2* e2_xvector = dynamic_cast<const e2*>(&xvector);
1406  const e3* e3_xvector = dynamic_cast<const e3*>(&xvector);
1407 
1408  e3* e3_xresult = dynamic_cast<e3*>(&xresult);
1409 
1410  if(jcb_e13_xjcb && e1_xvector && e3_xresult)
1411  {
1412  push(*jcb_e13_xjcb, *e1_xvector, *e3_xresult, xauto_access);
1413  }
1414  else if(jcb_e23_xjcb && e2_xvector && e3_xresult)
1415  {
1416  push(*jcb_e23_xjcb, *e2_xvector, *e3_xresult, xauto_access);
1417  }
1418  else if(jcb_e33_xjcb && e3_xvector && e3_xresult)
1419  {
1420  push(*jcb_e33_xjcb, *e3_xvector, *e3_xresult, xauto_access);
1421  }
1422  else
1423  {
1424  post_fatal_error_message(\
1425  "Unsupported argument types in call to push(...)");
1426  }
1427 
1428  // Postconditions:
1429 
1430  ensure(xresult.is_contravariant(0, xauto_access)); // !is_dual
1431 
1432  // Exit:
1433 
1434  return;
1435 }
1436 
1438 void
1440 pull(const jcb& xjcb, const at1& xcovector, at1& xresult, bool xauto_access)
1441 {
1442  // Preconditions:
1443 
1444  require(xjcb.state_is_auto_read_accessible(xauto_access));
1445  require(xcovector.state_is_auto_read_accessible(xauto_access));
1446  require(xresult.state_is_auto_read_write_accessible(xauto_access));
1447  require(xcovector.d(xauto_access) == xjcb.dr(xauto_access));
1448  require(xresult.d(xauto_access) == xjcb.dd(xauto_access));
1449  require(xcovector.is_covariant(0, xauto_access)); // is_dual
1450  require(xresult.is_covariant(0, xauto_access)); // is_dual
1451 
1452  // Body:
1453 
1454  // jcb_e13:
1455  // xcovector == e3
1456  // xresult == e1
1457 
1458  // jcb_e23:
1459  // xcovector == e3
1460  // xresult == e2
1461 
1462  // jcb_e33:
1463  // xcovector == e3
1464  // xresult == e3
1465 
1466  const jcb_e13* jcb_e13_xjcb = dynamic_cast<const jcb_e13*>(&xjcb);
1467  const jcb_e23* jcb_e23_xjcb = dynamic_cast<const jcb_e23*>(&xjcb);
1468  const jcb_e33* jcb_e33_xjcb = dynamic_cast<const jcb_e33*>(&xjcb);
1469 
1470  const e3* e3_xcovector = dynamic_cast<const e3*>(&xcovector);
1471 
1472  e1* e1_xresult = dynamic_cast<e1*>(&xresult);
1473  e2* e2_xresult = dynamic_cast<e2*>(&xresult);
1474  e3* e3_xresult = dynamic_cast<e3*>(&xresult);
1475 
1476  if(jcb_e13_xjcb && e3_xcovector && e1_xresult)
1477  {
1478  pull(*jcb_e13_xjcb, *e3_xcovector, *e1_xresult, xauto_access);
1479  }
1480  else if(jcb_e23_xjcb && e3_xcovector && e2_xresult)
1481  {
1482  pull(*jcb_e23_xjcb, *e3_xcovector, *e2_xresult, xauto_access);
1483  }
1484  else if(jcb_e33_xjcb && e3_xcovector && e3_xresult)
1485  {
1486  pull(*jcb_e33_xjcb, *e3_xcovector, *e3_xresult, xauto_access);
1487  }
1488  else
1489  {
1490  post_fatal_error_message(\
1491  "Unsupported argument types in call to pull(...)");
1492  }
1493 
1494  // Postconditions:
1495 
1496  ensure(xresult.is_covariant(0, xauto_access)); // is_dual
1497 
1498  // Exit:
1499 
1500  return;
1501 }
1502 
1504 void
1506 push(const jcb_lite& xjcb, const at1_lite& xvector, at1_lite& xresult)
1507 {
1508  // Preconditions:
1509 
1510  require(xvector.d() == xjcb.dd());
1511  require(xresult.d() == xjcb.dr());
1512  require(unexecutable("xvector.is_contravariant())")); // !is_dual
1513  require(unexecutable("xresult.is_contravariant())")); // !is_dual
1514 
1515  // Body:
1516 
1517  const jcb_e13_lite* jcb_e13_xjcb = dynamic_cast<const jcb_e13_lite*>(&xjcb);
1518  const jcb_e23_lite* jcb_e23_xjcb = dynamic_cast<const jcb_e23_lite*>(&xjcb);
1519  const jcb_e33_lite* jcb_e33_xjcb = dynamic_cast<const jcb_e33_lite*>(&xjcb);
1520 
1521  const e1_lite* e1_xvector = dynamic_cast<const e1_lite*>(&xvector);
1522  const e2_lite* e2_xvector = dynamic_cast<const e2_lite*>(&xvector);
1523  const e3_lite* e3_xvector = dynamic_cast<const e3_lite*>(&xvector);
1524 
1525  e3_lite* e3_xresult = dynamic_cast<e3_lite*>(&xresult);
1526 
1527  if(jcb_e13_xjcb && e1_xvector && e3_xresult)
1528  {
1529  push(*jcb_e13_xjcb, *e1_xvector, *e3_xresult);
1530  }
1531  else if(jcb_e23_xjcb && e2_xvector && e3_xresult)
1532  {
1533  push(*jcb_e23_xjcb, *e2_xvector, *e3_xresult);
1534  }
1535  else if(jcb_e33_xjcb && e3_xvector && e3_xresult)
1536  {
1537  push(*jcb_e33_xjcb, *e3_xvector, *e3_xresult);
1538  }
1539  else
1540  {
1541  post_fatal_error_message(\
1542  "Unsupported argument types in call to push(...)");
1543  }
1544 
1545  // Postconditions:
1546 
1547  //ensure(xresult.is_contravariant(0)); // !is_dual
1548 
1549  // Exit:
1550 
1551  return;
1552 }
1553 
1557 push(const jcb_lite& xjcb, const at1_lite& xvector)
1558 {
1559  // Preconditions:
1560 
1561  require(precondition_of(push(xjcb, xvector, *result)));
1562 
1563  // Body:
1564 
1565  at1_lite* result = new at1_lite();
1566  push(xjcb, xvector, *result);
1567 
1568  // Postconditions:
1569 
1570  ensure(postcondition_of(push(xjcb, xvector, *result)));
1571 
1572  // Exit:
1573 
1574  return result;
1575 
1576 }
1577 
1579 void
1581 pull(const jcb_lite& xjcb, const at1_lite& xcovector, at1_lite& xresult)
1582 {
1583  // Preconditions:
1584 
1585  require(xcovector.d() == xjcb.dr());
1586  require(xresult.d() == xjcb.dd());
1587  require(unexecutable("xcovector.is_covariant())")); // is_dual
1588  require(unexecutable("xresult.is_covariant())")); // is_dual
1589 
1590  // Body:
1591 
1592  const jcb_e13_lite* jcb_e13_xjcb = dynamic_cast<const jcb_e13_lite*>(&xjcb);
1593  const jcb_e23_lite* jcb_e23_xjcb = dynamic_cast<const jcb_e23_lite*>(&xjcb);
1594  const jcb_e33_lite* jcb_e33_xjcb = dynamic_cast<const jcb_e33_lite*>(&xjcb);
1595 
1596  const e3_lite* e3_xcovector = dynamic_cast<const e3_lite*>(&xcovector);
1597 
1598  e1_lite* e1_xresult = dynamic_cast<e1_lite*>(&xresult);
1599  e2_lite* e2_xresult = dynamic_cast<e2_lite*>(&xresult);
1600  e3_lite* e3_xresult = dynamic_cast<e3_lite*>(&xresult);
1601 
1602  if(jcb_e13_xjcb && e3_xcovector && e1_xresult)
1603  {
1604  pull(*jcb_e13_xjcb, *e3_xcovector, *e1_xresult);
1605  }
1606  else if(jcb_e23_xjcb && e3_xcovector && e2_xresult)
1607  {
1608  pull(*jcb_e23_xjcb, *e3_xcovector, *e2_xresult);
1609  }
1610  else if(jcb_e33_xjcb && e3_xcovector && e3_xresult)
1611  {
1612  pull(*jcb_e33_xjcb, *e3_xcovector, *e3_xresult);
1613  }
1614  else
1615  {
1616  post_fatal_error_message(\
1617  "Unsupported argument types in call to pull(...)");
1618  }
1619 
1620  // Postconditions:
1621 
1622  //ensure(xresult.is_covariant(0, xauto_access)); // is_dual
1623 
1624  // Exit:
1625 
1626  return;
1627 }
1628 
1632 pull(const jcb_lite& xjcb, const at1_lite& xcovector)
1633 {
1634  // Preconditions:
1635 
1636  require(precondition_of(pull(xjcb, xcovector, *result)));
1637 
1638  // Body:
1639 
1640  at1_lite* result = new at1_lite();
1641  pull(xjcb, xcovector, *result);
1642 
1643  // Postconditions:
1644 
1645  ensure(postcondition_of(pull(xjcb, xcovector, *result)));
1646 
1647  // Exit:
1648 
1649  return result;
1650 
1651 }
1652 
virtual bool is_contravariant(bool xauto_access) const
True if and only if all tensor index positions are contravariant.
Definition: tp.cc:1160
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 ...
value_type component(int xrow, int xcolumn) const
The value of the component in a specified row and column (const version).
Definition: jcb.cc:229
Jacobian of a map from a 3 dimensional domain (u, v, w) to a 3 dimensional Euclidean space (x...
Definition: jcb_e33.h:144
virtual int d() const
Dimension of this as a vector space.
Definition: jcb.cc:311
vd_value_type value_type
The type of component in the fiber; the scalar type in the fiber vector space.
Definition: vd.h:129
bool full() const
True if both poset name and member name are not empty.
Definition: poset_path.cc:311
Euclidean vector space of dimension 3 (volatile version).
Definition: e3.h:116
int d
Dimension of this as a vector space.
virtual const std::string & class_name() const
The name of this class.
Definition: jcb.cc:353
Euclidean vector space of dimension 2 (persistent version).
Definition: e2.h:405
poset_path domain_path() const
The path of the domain vector space.
Definition: jcb.cc:873
Jacobian of a map from a 2 dimensional domain (u, v) to a 3 dimensional Euclidean space (x...
Definition: jcb_e23.h:421
Jacobian of a map from a 1 dimensional domain (u) to a 3 dimensional Euclidean space (x...
Definition: jcb_e13.h:147
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...
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.
A general antisymmetric tensor of degree 1 over an abstract vector space (persistent version)...
Definition: at1.h:211
The standard fiber bundles name space; extends the standard sheaves namespace by defining base space...
virtual bool is_ancestor_of(const any_lite &xother) const
Conformance test; true if other conforms to this.
Definition: jcb.cc:424
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...
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.
static host_type & new_host(namespace_type &xns, const poset_path &xhost_path, const poset_path &xschema_path, const poset_path &xdomain_path, const poset_path &xrange_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: jcb.cc:544
void put_component(int xrow, int xcolumn, value_type xvalue)
Sets the component with row index xrow and column index xcolumn to xvalue.
Definition: jcb.cc:1093
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
STL namespace.
int factor_ct
Number of factors (components) in tuple.
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.
value_type component(int xrow, int xcolumn) const
The component with row index xrow and column index xcolumn.
Definition: jcb.cc:1037
virtual bool host_is_ancestor_of(const poset_state_handle *other) const
True if other conforms to host.
Definition: jcb.cc:1231
bool invariant() const
Class invariant.
Definition: jcb.cc:443
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).
virtual bool is_covariant(bool xauto_access) const
True if and only if all tensor index positions are covariant.
Definition: tp.cc:1078
Euclidean vector space of dimension 1 (persistent version).
Definition: e1.h:400
static void make_standard_schema(namespace_poset &xns)
Creates the standard schema for this class in namespace xns.
Definition: jcb.cc:507
int dr
Dimension of the range.
virtual const volatile_type & lite_prototype() const
Virtual constructor for the associated volatile type.
Definition: jcb.cc:796
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
Abstract vector space over dof_type (volatile version).
Definition: vd.h:111
virtual int index_for_row_column(int xrow, int xcolumn) const
The index into linear storage of the component in a specified row and column.
Definition: jcb.cc:274
Table dofs type for class jcb.
Euclidean vector space of dimension 2 (volatile version).
Definition: e2.h:112
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...
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)
Abstract jacobian class (volatile version).
Definition: jcb.h:54
virtual void detach_from_state()
Detach this handle from its state, if any.
jcb_lite & operator=(const jcb_lite &xother)
Assignment operator.
Definition: jcb.cc:75
An index within the external ("client") scope of a given id space.
Definition: scoped_index.h:116
jcb()
Default constructor.
Definition: jcb.cc:617
virtual jcb & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: jcb.cc:740
std::string poset_name() const
The poset name part of the path.
Definition: poset_path.cc:473
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
c_string domain_path
The path of the domain vector space.
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. ...
~jcb()
Destructor.
Definition: jcb.cc:783
Jacobian of a map from a 1 dimensional domain (u) to a 3 dimensional Euclidean space (x...
Definition: jcb_e13.h:433
virtual int d() const
Dimension of this as a vector space.
Definition: atp.cc:161
bool empty() const
True if both poset name and member name are empty.
Definition: poset_path.cc:291
table_dofs_type table_dofs() const
The table dofs.
Definition: jcb.cc:186
virtual int index_for_row_column(int xrow, int xcolumn) const
The index into linear storage of the component in a specified row and column.
Definition: jcb.cc:999
host_type * host() const
The poset this is a member of.
Definition: jcb.cc:1224
SHEAF_DLL_SPEC void pull(const jcb &xjcb, const at1 &xcovector, at1 &xresult, bool xauto_access)
Pull covector back (pre-allocated version for persistent types).
Definition: jcb.cc:1440
jcb_lite()
Default constructor.
Definition: jcb.cc:46
bool contains_poset(pod_index_type xhub_id, bool xauto_access=true) const
True if this contains a poset with hub id xhub_id..
static const std::string & static_class_name()
The name of this class.
Definition: jcb.cc:1194
virtual int dd() const
Dimension of the domain.
Definition: jcb.cc:831
Abstract jacobian class.
Definition: jcb.h:229
poset_path scalar_space_path() const
The path of the underlying space of scalars.
Definition: vd_space.cc:250
virtual jcb * clone() const
Make a new handle, no state instance of current.
Definition: jcb.cc:1276
Jacobian of a map from a 3 dimensional domain (u, v, w) to a 3 dimensional Euclidean space (x...
Definition: jcb_e33.h:434
Jacobian of a map from a 2 dimensional domain (u, v) to a 3 dimensional Euclidean space (x...
Definition: jcb_e23.h:142
An abstract vector space viewed as an antisymmetric tensor space of degree 1.
Definition: at1_space.h:42
virtual volatile_type * lite_type() const
Virtual conversion to the associated volatile type.
Definition: jcb.cc:814
c_string range_path
The path of the range vector space.
virtual jcb_lite * clone() const
Virtual constructor, makes a new instance of the same type as this.
Definition: jcb.cc:391
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: jcb.cc:1250
An abstract space of Jacobians.
Definition: jcb_space.h:46
int_type pod_index_type
The plain old data index type.
Definition: pod_types.h:49
virtual ~jcb_lite()
Destructor.
Definition: jcb.cc:93
int dd
Dimension of the domain.
virtual const std::string & class_name() const
The name of this class.
Definition: jcb.cc:1175
virtual int dr() const
Dimension of the range.
Definition: jcb.cc:165
static const poset_path & standard_schema_path()
The path to the standard schema for this class.
Definition: jcb.cc:486
vd_value_type value_type
The POD ("plain old data") type of scalar in the vector space of this.
Definition: vd.h:423
virtual int dd() const
Dimension of the domain.
Definition: jcb.cc:145
Euclidean vector space of dimension 1 (volatile version).
Definition: e1.h:113
poset_path range_path() const
The path of the range vector space.
Definition: jcb.cc:957
virtual int d() const
Dimension of this as a vector space.
Definition: vd.cc:1017
void put_component(int xrow, int xcolumn, value_type xcomp)
Sets value of a component in a specified row and column.
Definition: jcb.cc:251
bool invariant() const
Class invariant.
Definition: jcb.cc:1300
virtual int dr() const
Dimension of the range.
Definition: jcb.cc:915
An abstract client handle for a member of a poset.
c_string scalar_space_path
The path of the underlying scalar space.
SHEAF_DLL_SPEC void push(const jcb &xjcb, const at1 &xvector, at1 &xresult, bool xauto_access)
Push vector forward (pre-allocated version for persistent types).
Definition: jcb.cc:1374
Namespace for the fiber_bundles component of the sheaf system.
Row dofs type for class vd.
Definition: vd.h:61
static const std::string & static_class_name()
The name of this class.
Definition: jcb.cc:372
A client handle for a poset member which has been prepared for use as a schema.
SHEAF_DLL_SPEC std::ostream & operator<<(std::ostream &os, const binary_index &xbi)
Insert binary_index& xbi into ostream& os.
Definition: binary_index.cc:35
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