SheafSystem  0.0.0.0
jcb_e23.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_e23.impl.h"
22 
23 #include "SheafSystem/abstract_poset_member.impl.h"
24 #include "SheafSystem/assert_contract.h"
25 #include "SheafSystem/at1_space.h"
26 #include "SheafSystem/e2.h"
27 #include "SheafSystem/e3.h"
28 #include "SheafSystem/jcb_space.h"
29 #include "SheafSystem/fiber_bundles_namespace.h"
30 #include "SheafSystem/schema_poset_member.h"
31 #include "SheafSystem/st2_e2.h"
32 #include "SheafSystem/wsv_block.h"
33 
34 using namespace std;
35 using namespace fiber_bundle; // Workaround for MS C++ bug.
36 
37 
38 //==============================================================================
39 // CLASS JCB_E23_LITE
40 //==============================================================================
41 
42 
43 //============================================================================
44 // JCB_E23 FACET OF CLASS JCB_E23_LITE
45 //============================================================================
46 
49 {
50 
51  // Preconditions:
52 
53  // Body:
54 
55  // Postconditions:
56 
57  ensure(invariant());
58 
59  // Exit:
60 }
61 
63 jcb_e23_lite(const jcb_e23_lite& xother)
64 {
65  // Preconditions:
66 
67  // Body:
68 
69  *this = xother;
70 
71  // Postconditions:
72 
73  ensure(invariant());
74 
75  // Exit:
76 }
77 
80 operator=(const jcb_e23_lite& xother)
81 {
82 
83  // Preconditions:
84 
85  // Body:
86 
87  if(this == &xother)
88  return *this;
89 
90  _row_dofs = xother._row_dofs;
91 
92  // Postconditions:
93 
94  ensure(invariant());
95  ensure_for_all(i, 0, d(), component(i) == xother[i]);
96 
97  // Exit:
98 
99  return *this;
100 }
101 
104 {
105 
106  // Preconditions:
107 
108  // Body:
109 
110  // Postconditions:
111 
112  // Exit:
113 
114 }
115 
117 jcb_e23_lite(const row_dofs_type& xrow_dofs)
118 {
119  // Preconditions:
120 
121  // Body:
122 
123  *this = xrow_dofs;
124 
125  // Postconditions:
126 
127  ensure(invariant());
128 
129  // Exit:
130 }
131 
133 jcb_e23_lite(const matrix_type& xmatrix)
134 {
135  // Preconditions:
136 
137  // Body:
138 
139  *this = xmatrix;
140 
141  // Postconditions:
142 
143  ensure(invariant());
144 
145  // Exit:
146 }
147 
150 operator=(const row_dofs_type& xrow_dofs)
151 {
152  // Preconditions:
153 
154  // Body:
155 
156  _row_dofs = xrow_dofs;
157 
158  // Postconditions:
159 
160  ensure(invariant());
161 
162  // Exit:
163 
164  return *this;
165 
166 }
167 
170 operator=(const matrix_type& xmatrix)
171 {
172  // Preconditions:
173 
174  // Body:
175 
176  //_row_dofs = xmatrix;
177  _row_dofs = reinterpret_cast<const row_dofs_type&>(xmatrix);
178 
179  // Postconditions:
180 
181  ensure(invariant());
182 
183  // Exit:
184 
185  return *this;
186 
187 }
188 
189 fiber_bundle::jcb_e23_lite::
191 {
192  // Preconditions:
193 
194  // Body:
195 
196  row_dofs_type& result = _row_dofs;
197 
198  // Postconditions:
199 
200  // Exit:
201 
202  return result;
203 }
204 
205 fiber_bundle::jcb_e23_lite::
206 operator const jcb_e23_lite::row_dofs_type& () const
207 {
208  // Preconditions:
209 
210  // Body:
211 
212  const row_dofs_type& result = _row_dofs;
213 
214  // Postconditions:
215 
216  // Exit:
217 
218  return result;
219 }
220 
221 fiber_bundle::jcb_e23_lite::
223 {
224  // Preconditions:
225 
226  // Body:
227 
228  matrix_type& result = _row_dofs;
229 
230  // Postconditions:
231 
232  // Exit:
233 
234  return result;
235 
236 }
237 
238 fiber_bundle::jcb_e23_lite::
239 operator const jcb_e23_lite::matrix_type& () const
240 {
241  // Preconditions:
242 
243  // Body:
244 
245  const matrix_type& result = _row_dofs;
246 
247  // Postconditions:
248 
249  // Exit:
250 
251  return result;
252 }
253 
255 jcb_e23_lite(const value_type& dxdu, const value_type& dxdv,
256  const value_type& dydu, const value_type& dydv,
257  const value_type& dzdu, const value_type& dzdv)
258 {
259  // Preconditions:
260 
261  // Body:
262 
263  put_components(dxdu, dxdv, dydu, dydv, dzdu, dzdv);
264 
265  // Postconditions:
266 
267  ensure(invariant());
268  ensure(isunordered_or_equals(component(0), dxdu));
269  ensure(isunordered_or_equals(component(1), dxdv));
270  ensure(isunordered_or_equals(component(2), dydu));
271  ensure(isunordered_or_equals(component(3), dydv));
272  ensure(isunordered_or_equals(component(4), dzdu));
273  ensure(isunordered_or_equals(component(5), dzdv));
274 
275  // Exit:
276 }
277 
278 void
280 put_components(const value_type& dxdu, const value_type& dxdv,
281  const value_type& dydu, const value_type& dydv,
282  const value_type& dzdu, const value_type& dzdv)
283 {
284  // Preconditions:
285 
286  // Body:
287 
288  put_component(0, dxdu);
289  put_component(1, dxdv);
290  put_component(2, dydu);
291  put_component(3, dydv);
292  put_component(4, dzdu);
293  put_component(5, dzdv);
294 
295  // Postconditions:
296 
297  ensure(invariant());
298 
299  ensure(isunordered_or_equals(component(0), dxdu));
300  ensure(isunordered_or_equals(component(1), dxdv));
301  ensure(isunordered_or_equals(component(2), dydu));
302  ensure(isunordered_or_equals(component(3), dydv));
303  ensure(isunordered_or_equals(component(4), dzdu));
304  ensure(isunordered_or_equals(component(5), dzdv));
305 
306  // Exit:
307 }
308 
309 // PROTECTED MEMBER FUNCTIONS
310 
311 // PRIVATE MEMBER FUNCTIONS
312 
313 
314 //============================================================================
315 // JCB_ED FACET OF CLASS JCB_E23_LITE
316 //============================================================================
317 
318 // PUBLIC MEMBER FUNCTIONS
319 
320 // PROTECTED MEMBER FUNCTIONS
321 
322 // PRIVATE MEMBER FUNCTIONS
323 
324 
325 //============================================================================
326 // JACOBIAN (JCB) FACET OF CLASS JCB_E23_LITE
327 //============================================================================
328 
329 // PUBLIC MEMBER FUNCTIONS
330 
331 int
333 dd() const
334 {
335  // Preconditions:
336 
337  // Body:
338 
339  int result = 2;
340 
341  // Postconditions:
342 
343  ensure(invariant());
344  ensure(result == 2);
345 
346  // Exit:
347 
348  return result;
349 }
350 
351 int
353 dr() const
354 {
355  // Preconditions:
356 
357  // Body:
358 
359  int result = 3;
360 
361  // Postconditions:
362 
363  ensure(invariant());
364  ensure(result == 3);
365 
366  // Exit:
367 
368  return result;
369 }
370 
371 // PROTECTED MEMBER FUNCTIONS
372 
373 // PRIVATE MEMBER FUNCTIONS
374 
375 
376 //============================================================================
377 // VECTOR ALGEBRA (VD) FACET OF CLASS JCB_E23_LITE
378 //============================================================================
379 
380 // PUBLIC MEMBER FUNCTIONS
381 
382 
383 // PROTECTED MEMBER FUNCTIONS
384 
385 // PRIVATE MEMBER FUNCTIONS
386 
387 
388 //============================================================================
389 // CARTESIAN ALGEBRA (TUPLE) FACET OF CLASS JCB_E23_LITE
390 //============================================================================
391 
392 // PUBLIC MEMBER FUNCTIONS
393 
394 // PROTECTED MEMBER FUNCTIONS
395 
396 // PRIVATE MEMBER FUNCTIONS
397 
398 
399 //============================================================================
400 // ABSTRACT POSET MEMBER FACET OF CLASS JCB_E23_LITE
401 //============================================================================
402 
403 // PUBLIC MEMBER FUNCTIONS
404 
405 const std::string&
407 class_name() const
408 {
409  // Preconditions:
410 
411  // Body:
412 
413  const string& result = static_class_name();
414 
415  // Postconditions:
416 
417  ensure(!result.empty());
418 
419  // Exit:
420 
421  return result;
422 }
423 
424 const std::string&
427 {
428  // Preconditions:
429 
430  // Body:
431 
432  static const string result("jcb_e23_lite");
433 
434  // Postconditions:
435 
436  ensure(!result.empty());
437 
438  // Exit:
439 
440  return result;
441 }
442 
445 clone() const
446 {
447  jcb_e23_lite* result = 0;
448 
449  // Preconditions:
450 
451  // Body:
452 
453  result = new jcb_e23_lite();
454 
455  // Postconditions:
456 
457  ensure(result != 0);
458  ensure(is_same_type(*result));
459 
460  // Exit:
461 
462  return result;
463 }
464 
465 // PROTECTED MEMBER FUNCTIONS
466 
467 // PRIVATE MEMBER FUNCTIONS
468 
469 
470 //============================================================================
471 // ANY FACET OF CLASS JCB_E23_LITE
472 //============================================================================
473 
474 // PUBLIC MEMBER FUNCTIONS
475 
476 bool
478 is_ancestor_of(const any_lite& xother) const
479 {
480  // Preconditions:
481 
482  require(&xother != 0);
483 
484  // Body:
485 
486  // True if other conforms to this.
487 
488  bool result = dynamic_cast<const jcb_e23_lite*>(&xother) != 0;
489 
490  // Postconditions:
491 
492  return result;
493 }
494 
495 bool
497 invariant() const
498 {
499  bool result = true;
500 
501  if(invariant_check())
502  {
503  // Prevent recursive calls to invariant.
504 
505  disable_invariant_check();
506 
507  // Must satisfy base class invariant.
508 
509  invariance(jcb_ed_lite::invariant());
510 
511  // Invariances for this class:
512 
513  // Finished, turn invariant checking back on.
514 
515  enable_invariant_check();
516  }
517 
518  // Exit
519 
520  return result;
521 }
522 
523 void*
526 {
527  return &_row_dofs;
528 }
529 
530 const void*
532 row_dofs() const
533 {
534  return &_row_dofs;
535 }
536 
537 // PROTECTED MEMBER FUNCTIONS
538 
539 // PRIVATE MEMBER FUNCTIONS
540 
541 
542 //==============================================================================
543 // CLASS JCB_E23
544 //==============================================================================
545 
546 // ===========================================================
547 // HOST FACTORY FACET
548 // ===========================================================
549 
550 // PUBLIC MEMBER FUNCTIONS
551 
552 const sheaf::poset_path&
555 {
556  // Preconditions:
557 
558 
559  // Body:
560 
561  static const poset_path result(standard_schema_poset_name(), "jcb_e23_schema");
562 
563  // Postconditions:
564 
565  // Exit:
566 
567  return result;
568 }
569 
570 void
573 {
574  // Preconditions:
575 
576  require(xns.state_is_read_write_accessible());
577  require(xns.contains_poset(standard_schema_poset_name()));
578  require(!xns.contains_poset_member(standard_schema_path()));
579 
580  // Body:
581 
582  string lmember_names = "dxdu DOUBLE false ";
583  lmember_names += "dxdv DOUBLE false ";
584  lmember_names += "dydu DOUBLE false ";
585  lmember_names += "dydv DOUBLE false ";
586  lmember_names += "dzdu DOUBLE false ";
587  lmember_names += "dzdv DOUBLE false";
588 
589  schema_poset_member lschema(xns,
590  standard_schema_path().member_name(),
591  jcb_ed::standard_schema_path(),
592  lmember_names,
593  false);
594 
595  lschema.detach_from_state();
596 
597  // Postconditions:
598 
599  ensure(xns.contains_poset_member(standard_schema_path()));
600 
601  // Exit:
602 
603  return;
604 }
605 
609  const poset_path& xhost_path,
610  const poset_path& xschema_path,
611  const poset_path& xdomain_path,
612  const poset_path& xrange_path,
613  bool xauto_access)
614 {
615  // cout << endl << "Entering jcb_e23::new_host." << endl;
616 
617  // Preconditions:
618 
619  require(xns.state_is_auto_read_write_accessible(xauto_access));
620 
621  require(!xhost_path.empty());
622  require(!xns.contains_path(xhost_path, xauto_access));
623 
624  require(xschema_path.full());
625  require(xns.path_is_auto_read_accessible(xschema_path, xauto_access));
626  require(schema_poset_member::conforms_to(xns, xschema_path, standard_schema_path()));
627  require(schema_poset_member::row_dof_ct(xns, xschema_path, xauto_access) == 6);
628 
629  require(xns.path_is_auto_read_accessible(xdomain_path, xauto_access));
630  require(xns.contains_poset<domain_type::host_type>(xdomain_path, xauto_access));
631  require(xns.member_poset(xdomain_path, xauto_access).schema(xauto_access).conforms_to(domain_type::standard_schema_path()));
632  require(xns.member_poset<domain_type::host_type>(xdomain_path, xauto_access).d(xauto_access) == 2);
633 
634  require(xns.path_is_auto_read_accessible(xrange_path, xauto_access));
635  require(xns.contains_poset<range_type::host_type>(xrange_path, xauto_access));
636  require(xns.member_poset(xrange_path, xauto_access).schema(xauto_access).conforms_to(range_type::standard_schema_path()));
637  require(xns.member_poset<range_type::host_type>(xrange_path, xauto_access).d(xauto_access) == 3);
638 
639  require(host_type::d(xns, xschema_path, xauto_access) == host_type::d(xns, xdomain_path, xrange_path, xauto_access));
640 
641  require(xns.member_poset<domain_type::host_type>(xdomain_path, xauto_access).scalar_space_path(xauto_access) ==
642  xns.member_poset<range_type::host_type>(xrange_path, xauto_access).scalar_space_path(xauto_access));
643 
644  // Body:
645 
646  host_type& result =
647  host_type::new_table(xns, xhost_path, xschema_path, xdomain_path, xrange_path, xauto_access);
648 
649  // Postconditions:
650 
651  ensure(xns.owns(result, xauto_access));
652  ensure(result.path(true) == xhost_path);
653  ensure(result.state_is_not_read_accessible());
654  ensure(result.schema(true).path(xauto_access) == xschema_path);
655 
656  ensure(result.factor_ct(true) == 6);
657  ensure(result.d(true) == 6);
658  ensure(result.dd(true) == 2);
659  ensure(result.dr(true) == 3);
660  ensure(result.domain_path(true) == xdomain_path);
661  ensure(result.range_path(true) == xrange_path);
662 
663  ensure(result.scalar_space_path(true) ==
664  xns.member_poset<domain_type::host_type>(xdomain_path, xauto_access).scalar_space_path(xauto_access) );
665  ensure(result.scalar_space_path(true) ==
666  xns.member_poset<range_type::host_type>(xrange_path, xauto_access).scalar_space_path(xauto_access) );
667 
668  // Exit:
669 
670  // cout << "Leaving jcb_e23::new_host." << endl;
671  return result;
672 }
673 
676 standard_host(namespace_type& xns, const std::string& xsuffix, bool xauto_access)
677 {
678  // cout << endl << "Entering jcb_e23::new_host." << endl;
679 
680  // Preconditions:
681 
682  require(xns.state_is_auto_read_write_accessible(xauto_access));
683 
684  require(xsuffix.empty() || poset_path::is_valid_name(xsuffix));
685  require(standard_host_is_available<jcb_e23>(xns, xsuffix, xauto_access));
686 
687  require(xns.path_is_auto_read_accessible(standard_schema_path(), xauto_access));
688 
689  require(xns.path_is_auto_read_available(standard_host_path<domain_type>(xsuffix), xauto_access));
690  require(xns.path_is_auto_read_available(standard_host_path<range_type>(xsuffix), xauto_access));
691 
692  // Body:
693 
694  // Create the domain space if necessary.
695 
696  poset_path ldomain_space_path = domain_type::standard_host(xns, xsuffix, xauto_access).path(true);
697 
698  // Create the range space if necessary.
699 
700  poset_path lrange_space_path = range_type::standard_host(xns, xsuffix, xauto_access).path(true);
701 
702  poset_path lpath(standard_host_path<jcb_e23>(xsuffix));
703 
704  host_type* result_ptr;
705  if(xns.contains_path(lpath, xauto_access))
706  {
707  result_ptr = &xns.member_poset<host_type>(lpath, xauto_access);
708  }
709  else
710  {
711  result_ptr = &new_host(xns, lpath, standard_schema_path(), ldomain_space_path, lrange_space_path, xauto_access);
712  }
713 
714  host_type& result = *result_ptr;
715 
716  // Postconditions:
717 
718  ensure(xns.owns(result, xauto_access));
719  ensure(result.path(true) == standard_host_path<jcb_e23>(xsuffix));
720  ensure(result.state_is_not_read_accessible());
721  ensure(result.schema(true).path(xauto_access) == standard_schema_path());
722 
723  ensure(result.factor_ct(true) == 6);
724  ensure(result.d(true) == 6);
725  ensure(result.dd(true) == 2);
726  ensure(result.dr(true) == 3);
727  ensure(result.domain_path(true) == standard_host_path<domain_type>(xsuffix));
728  ensure(result.range_path(true) == standard_host_path<range_type>(xsuffix));
729 
730  ensure(result.scalar_space_path(true) == standard_host_path<domain_type::scalar_type>(xsuffix));
731  ensure(result.scalar_space_path(true) == standard_host_path<domain_type::scalar_type>(xsuffix));
732 
733  // Exit:
734 
735  // cout << "Leaving jcb_e23::new_host." << endl;
736  return result;
737 }
738 
739 // PROTECTED MEMBER FUNCTIONS
740 
741 // PRIVATE MEMBER FUNCTIONS
742 
743 
744 //============================================================================
745 // JCB_E23 FACET OF CLASS JCB_E23
746 //============================================================================
747 
748 // PUBLIC MEMBER FUNCTIONS
749 
752 {
753 
754  // Preconditions:
755 
756  // Body:
757 
758  // Postconditions:
759 
760  ensure(invariant());
761 
762  // Exit:
763 }
764 
767 {
768  // Preconditions:
769 
770  require(xhost != 0);
771  require(xhost->state_is_read_accessible());
772  require(xhost->contains_member(xhub_id));
773 
774  // Body:
775 
776  attach_to_state(xhost, xhub_id);
777 
778  // Postconditions:
779 
780  ensure(invariant());
781  // ensure(host() == xhost);
782  ensure(index() == xhub_id);
783  ensure(is_attached());
784 }
785 
787 jcb_e23(const poset_state_handle* xhost, const scoped_index& xid)
788 {
789  // Preconditions:
790 
791  require(xhost != 0);
792  require(xhost->state_is_read_accessible());
793  require(xhost->contains_member(xid));
794 
795  // Body:
796 
797  attach_to_state(xhost, xid.hub_pod());
798 
799  // Postconditions:
800 
801  ensure(invariant());
802  // ensure(host() == xhost);
803  ensure(index() ==~ xid);
804  ensure(is_attached());
805 }
806 
808 jcb_e23(const poset_state_handle* xhost, const std::string& xname)
809 {
810 
811  // Preconditions:
812 
813  require(xhost != 0);
814  require(xhost->state_is_read_accessible());
815  require(!xname.empty());
816  require(xhost->contains_member(xname));
817 
818  // Body:
819 
820  attach_to_state(xhost, xname);
821 
822  // Postconditions:
823 
824  ensure(invariant());
825  // ensure(host() == xhost);
826  ensure(name() == xname);
827  ensure(is_attached());
828 
829 }
830 
833 {
834 
835  // Preconditions:
836 
837  require(xother != 0);
838 
839  // Body:
840 
841  attach_to_state(xother);
842 
843  // Postconditions:
844 
845  ensure(invariant());
846  ensure(is_attached());
847  ensure(is_same_state(xother));
848 
849 }
850 
852 jcb_e23(poset_state_handle* xhost, bool xauto_access)
853 {
854 
855  // Preconditions:
856 
857  require(precondition_of(new_jim_state(xhost, 0, false, xauto_access)));
858 
859  // Body:
860 
861  new_jim_state(xhost, 0, false, xauto_access);
862 
863  // Postconditions:
864 
865  ensure(postcondition_of(new_jim_state(xhost, 0, false, xauto_access)));
866 
867  // Exit:
868 
869  return;
870 }
871 
874  const row_dofs_type& xrdt,
875  bool xauto_access)
876 {
877 
878  // Preconditions:
879 
880  require(precondition_of(new_jim_state(&xhost, 0, false, xauto_access)));
881 
882  // Body:
883 
884  new_jim_state(&xhost, 0, false, xauto_access);
885 
886  if(xauto_access)
887  {
888  xhost.get_read_write_access();
889  }
890 
891  *this = xrdt;
892 
893  if(xauto_access)
894  {
895  xhost.release_access();
896  }
897 
898  // Postconditions:
899 
900  ensure(postcondition_of(new_jim_state(&xhost, 0, false, xauto_access)));
901 
902  // Exit:
903 
904  return;
905 }
906 
910 {
911  // Preconditions:
912 
913  require(state_is_read_write_accessible());
914 
915  // Body:
916 
917  sheaf::row_dofs(*this) = xrdt;
918 
919  // Postconditions:
920 
921  ensure_for_all(i, 0, d(), component(i) == xrdt.components[i]);
922 
923  // Exit:
924 
925  return *this;
926 
927 }
928 
933 {
934  // Preconditions:
935 
936  require(is_ancestor_of(&xother));
937  require(precondition_of(attach_to_state(&xother)));
938 
939  // Body:
940 
941  attach_to_state(&xother);
942 
943  // Postconditions:
944 
945  ensure(postcondition_of(attach_to_state(&xother)));
946 
947  // Exit:
948 
949  return *this;
950 }
951 
955 operator=(const jcb_e23& xother)
956 {
957  // Preconditions:
958 
959  require(precondition_of(attach_to_state(&xother)));
960 
961  // Body:
962 
963  attach_to_state(&xother);
964 
965  // Postconditions:
966 
967  ensure(postcondition_of(attach_to_state(&xother)));
968 
969  // Exit:
970 
971  return *this;
972 }
973 
976 {
977 
978  // Preconditions:
979 
980  // Body:
981 
982  // Postconditions:
983 
984 }
985 
989 {
990  // Preconditions:
991 
992  // Body:
993 
994  static const volatile_type result;
995 
996  // Postconditions:
997 
998  // Exit:
999 
1000  return result;
1001 }
1002 
1006 lite_type() const
1007 {
1008  // Preconditions:
1009 
1010  // Body:
1011 
1012  volatile_type* result = new volatile_type(sheaf::row_dofs(*this));
1013 
1014  // Postconditions:
1015 
1016  // Exit:
1017 
1018  return result;
1019 }
1020 
1021 
1022 //============================================================================
1023 // ROW DOF RELATED MEMBER FUNCTIONS
1024 //============================================================================
1025 
1026 fiber_bundle::jcb_e23::
1028 {
1029  // Preconditions:
1030 
1031  // Body:
1032 
1033  row_dofs_type& result = sheaf::row_dofs(*this);
1034 
1035  // Postconditions:
1036 
1037  // Exit:
1038 
1039  return result;
1040 }
1041 
1042 fiber_bundle::jcb_e23::
1043 operator const jcb_e23::row_dofs_type& () const
1044 {
1045  // Preconditions:
1046 
1047  // Body:
1048 
1049  const row_dofs_type& result = sheaf::row_dofs(*this);
1050 
1051  // Postconditions:
1052 
1053  // Exit:
1054 
1055  return result;
1056 }
1057 
1058 // PROTECTED MEMBER FUNCTIONS
1059 
1060 // PRIVATE MEMBER FUNCTIONS
1061 
1062 
1063 //============================================================================
1064 // JCB_ED FACET OF CLASS JCB_E23
1065 //============================================================================
1066 
1067 // PUBLIC MEMBER FUNCTIONS
1068 
1069 // PROTECTED MEMBER FUNCTIONS
1070 
1071 // PRIVATE MEMBER FUNCTIONS
1072 
1073 
1074 //============================================================================
1075 // JCB FACET OF CLASS JCB_E23
1076 //============================================================================
1077 
1078 // PUBLIC MEMBER FUNCTIONS
1079 
1080 // PROTECTED MEMBER FUNCTIONS
1081 
1082 // PRIVATE MEMBER FUNCTIONS
1083 
1084 
1085 //============================================================================
1086 // VD FACET OF CLASS JCB_E23
1087 //============================================================================
1088 
1089 // PUBLIC MEMBER FUNCTIONS
1090 
1091 // PROTECTED MEMBER FUNCTIONS
1092 
1093 // PRIVATE MEMBER FUNCTIONS
1094 
1095 
1096 //============================================================================
1097 // TUPLE FACET OF CLASS JCB_E23
1098 //============================================================================
1099 
1100 // PUBLIC MEMBER FUNCTIONS
1101 
1102 // PROTECTED MEMBER FUNCTIONS
1103 
1104 // PRIVATE MEMBER FUNCTIONS
1105 
1106 
1107 //============================================================================
1108 // ABSTRACT POSET MEMBER FACET OF CLASS JCB_E23
1109 //============================================================================
1110 
1111 // PUBLIC MEMBER FUNCTIONS
1112 
1113 const std::string&
1115 class_name() const
1116 {
1117  // Preconditions:
1118 
1119  // Body:
1120 
1121  const string& result = static_class_name();
1122 
1123  // Postconditions:
1124 
1125  ensure(!result.empty());
1126 
1127  // Exit:
1128 
1129  return result;
1130 }
1131 
1132 const std::string&
1135 {
1136  // Preconditions:
1137 
1138  // Body:
1139 
1140  static const string result("jcb_e23");
1141 
1142  // Postconditions:
1143 
1144  ensure(!result.empty());
1145 
1146  // Exit:
1147 
1148  return result;
1149 }
1150 
1153 clone() const
1154 {
1155 
1156  // Preconditions:
1157 
1158  // Body:
1159 
1160  // Create new handle of the current class.
1161 
1162  jcb_e23* result = new jcb_e23();
1163 
1164  // Postconditions:
1165 
1166  ensure(result != 0);
1167  ensure(result->invariant());
1168 
1169  // Exit:
1170 
1171  return result;
1172 
1173 }
1174 
1175 // PROTECTED MEMBER FUNCTIONS
1176 
1177 // PRIVATE MEMBER FUNCTIONS
1178 
1179 
1180 //============================================================================
1181 // ANY FACET OF CLASS JCB_E23
1182 //============================================================================
1183 
1184 // PUBLIC MEMBER FUNCTIONS
1185 
1186 bool
1188 is_ancestor_of(const any* xother) const
1189 {
1190 
1191  // Preconditions:
1192 
1193  require(xother != 0);
1194 
1195  // Body:
1196 
1197  // If xother may be dynamically cast to the type of this then this is an
1198  // ancestor of xother.
1199 
1200  bool result = dynamic_cast<const jcb_e23*>(xother) != 0;
1201 
1202  // Postconditions:
1203 
1204  // ensure(invariant());
1205 
1206  // Exit:
1207 
1208  return result;
1209 
1210 }
1211 
1212 bool
1214 invariant() const
1215 {
1216  bool result = true;
1217 
1218  // Preconditions:
1219 
1220  // Body:
1221 
1222  // Must satisfy base class invariant.
1223 
1224  invariance(jcb_ed::invariant());
1225 
1226  if (invariant_check())
1227  {
1228  // Prevent recursive calls to invariant.
1229 
1230  disable_invariant_check();
1231 
1232  invariance(is_attached() ? (dr() == 3) : true);
1233  invariance(is_attached() ? (dd() == 2) : true);
1234 
1235  // Finished, turn invariant checking back on.
1236 
1237  enable_invariant_check();
1238  }
1239 
1240  // Postconditions:
1241 
1242  ensure(is_derived_query);
1243 
1244  // Exit:
1245 
1246  return result;
1247 }
1248 
1249 // PROTECTED MEMBER FUNCTIONS
1250 
1251 // PRIVATE MEMBER FUNCTIONS
1252 
1253 
1254 //==============================================================================
1255 // NON-MEMBER FUNCTIONS
1256 //==============================================================================
1257 
1259 void
1261 push(const jcb_e23& xjcb, const e2& xvector, e3& xresult, bool xauto_access)
1262 {
1263  // Preconditions:
1264 
1265  require(xjcb.state_is_auto_read_accessible(xauto_access));
1266  require(xvector.state_is_auto_read_accessible(xauto_access));
1267  require(xresult.state_is_auto_read_write_accessible(xauto_access));
1268  require(xvector.d(xauto_access) == xjcb.dd(xauto_access));
1269  require(xresult.d(xauto_access) == xjcb.dr(xauto_access));
1270 
1272 
1273  require(xvector.is_contravariant(0, xauto_access)); // !is_dual
1274 
1275  // Body:
1276 
1277  if(xauto_access)
1278  {
1279  xjcb.get_read_access();
1280  xvector.get_read_access();
1281  xresult.get_read_write_access(true);
1282  }
1283 
1284  // Left matrix multiply vector with jacobian.
1285 
1286  int num_rows = xjcb.dr();
1287  int num_cols = xjcb.dd();
1288 
1289  for(int i=0; i<num_rows; ++i)
1290  {
1291  vd_value_type sumi = 0.0;
1292  for(int j=0; j<num_cols; ++j)
1293  {
1294  vd_value_type vj = xvector.component(j);
1295  vd_value_type cij = xjcb.component(i, j);
1296  sumi += cij*vj;
1297  }
1298  xresult.put_component(i, sumi);
1299  }
1300 
1301  // Make sure the result is contravariant/p_vector.
1302 
1303  xresult.put_is_p_vector(false);
1304 
1305  if(xauto_access)
1306  {
1307  xjcb.release_access();
1308  xvector.release_access();
1309  xresult.release_access();
1310  }
1311 
1312  // Postconditions:
1313 
1314  ensure(xresult.is_contravariant(0, xauto_access)); // !is_dual
1315 
1316  // Exit:
1317 
1318  return;
1319 }
1320 
1322 void
1324 push(const jcb_e23_lite& xjcb, const e2_lite& xvector, e3_lite& xresult)
1325 {
1326  // Preconditions:
1327 
1328  require(xvector.d() == xjcb.dd());
1329  require(xresult.d() == xjcb.dr());
1330 
1332 
1333  require(unexecutable("xvector.is_contravariant())")); // !is_dual
1334 
1335  // Body:
1336 
1337  // Left matrix multiply vector with jacobian.
1338 
1339  int num_rows = xjcb.dr();
1340  int num_cols = xjcb.dd();
1341 
1342  for(int i=0; i<num_rows; ++i)
1343  {
1344  vd_value_type sumi = 0.0;
1345  for(int j=0; j<num_cols; ++j)
1346  {
1347  vd_value_type vj = xvector.component(j);
1348  vd_value_type cij = xjcb.component(i, j);
1349  sumi += cij*vj;
1350  }
1351  xresult.put_component(i, sumi);
1352  }
1353 
1354  // Postconditions:
1355 
1356  ensure(unexecutable("xresult.is_contravariant())")); // !is_dual
1357 
1358  // Exit:
1359 
1360  return;
1361 }
1362 
1366 push(const jcb_e23_lite& xjcb, const e2_lite& xvector)
1367 {
1368  // Preconditions:
1369 
1370  require(precondition_of(push(xjcb, xvector, *result)));
1371 
1372  // Body:
1373 
1374  e3_lite* result = new e3_lite();
1375 
1376  push(xjcb, xvector, *result);
1377 
1378  // Postconditions:
1379 
1380  ensure(postcondition_of(push(xjcb, xvector, *result)));
1381 
1382  // Exit:
1383 
1384  return result;
1385 
1386 }
1387 
1389 void
1391 pull(const jcb_e23& xjcb, const e3& xcovector, e2& xresult, bool xauto_access)
1392 {
1393  // Preconditions:
1394 
1395  require(xjcb.state_is_auto_read_accessible(xauto_access));
1396  require(xcovector.state_is_auto_read_accessible(xauto_access));
1397  require(xresult.state_is_auto_read_write_accessible(xauto_access));
1398  require(xcovector.d(xauto_access) == xjcb.dr(xauto_access));
1399  require(xresult.d(xauto_access) == xjcb.dd(xauto_access));
1400 
1402 
1403  require(xcovector.is_covariant(0, xauto_access)); // is_dual
1404 
1405  // Body:
1406 
1407  if(xauto_access)
1408  {
1409  xjcb.get_read_access();
1410  xcovector.get_read_access();
1411  xresult.get_read_write_access(true);
1412  }
1413 
1414  // Right matrix multiply covector with jacobian.
1415 
1416  int num_rows = xjcb.dd();
1417  int num_cols = xjcb.dr();
1418 
1419  for(int i=0; i<num_rows; ++i)
1420  {
1421  vd_value_type sumi = 0.0;
1422  for(int j=0; j<num_cols; ++j)
1423  {
1424  vd_value_type vj = xcovector.component(j);
1425  vd_value_type cji = xjcb.component(j, i);
1426  sumi += vj*cji;
1427  }
1428  xresult.put_component(i, sumi);
1429  }
1430 
1431  // Make sure the result is covariant/p_form.
1432 
1433  xresult.put_is_p_form(false);
1434 
1435  if(xauto_access)
1436  {
1437  xjcb.release_access();
1438  xcovector.release_access();
1439  xresult.release_access();
1440  }
1441 
1442  // Postconditions:
1443 
1444  ensure(xresult.is_covariant(0, xauto_access)); // is_dual
1445 
1446  // Exit:
1447 
1448  return;
1449 }
1450 
1452 void
1454 pull(const jcb_e23_lite& xjcb, const e3_lite& xcovector, e2_lite& xresult)
1455 {
1456  // Preconditions:
1457 
1458  require(xcovector.d() == xjcb.dr());
1459  require(xresult.d() == xjcb.dd());
1460  require(unexecutable("xcovector.is_covariant())")); // is_dual
1461 
1462  // Body:
1463 
1464  // Right matrix multiply covector with jacobian.
1465 
1466  int num_rows = xjcb.dd();
1467  int num_cols = xjcb.dr();
1468 
1469  for(int i=0; i<num_rows; ++i)
1470  {
1471  vd_value_type sumi = 0.0;
1472  for(int j=0; j<num_cols; ++j)
1473  {
1474  vd_value_type vj = xcovector.component(j);
1475  vd_value_type cji = xjcb.component(j, i);
1476  sumi += vj*cji;
1477  }
1478  xresult.put_component(i, sumi);
1479  }
1480 
1481  // Postconditions:
1482 
1483  ensure(unexecutable("xresult.is_covariant())")); // is_dual
1484 
1485  // Exit:
1486 
1487  return;
1488 }
1489 
1493 pull(const jcb_e23_lite& xjcb, const e3_lite& xcovector)
1494 {
1495  // Preconditions:
1496 
1497  require(precondition_of(pull(xjcb, xcovector, *result)));
1498 
1499  // Body:
1500 
1501  e2_lite* result = new e2_lite();
1502 
1503  pull(xjcb, xcovector, *result);
1504 
1505  // Postconditions:
1506 
1507  ensure(postcondition_of(pull(xjcb, xcovector, *result)));
1508 
1509  // Exit:
1510 
1511  return result;
1512 
1513 }
1514 
1515 //==============================================================================
1516 
1517 //@todo Decide what to with the following functions.
1518 
1520 void
1522 metric(const jcb_e23_lite& xjcb, st2_e2_lite& xresult)
1523 {
1524 
1525  // Preconditions:
1526 
1527  // Body:
1528 
1529  xresult[0] = xjcb[0]*xjcb[0] + xjcb[2]*xjcb[2] + xjcb[4]*xjcb[4];
1530  xresult[1] = xjcb[0]*xjcb[1] + xjcb[2]*xjcb[3] + xjcb[4]*xjcb[5];
1531  xresult[2] = xjcb[1]*xjcb[1] + xjcb[3]*xjcb[3] + xjcb[5]*xjcb[5];
1532 
1533  // Postconditions:
1534 
1535  // Exit:
1536 }
1537 
1539 void
1542  const jcb_e23_lite& xother_jcb,
1543  st2_e2_lite& xresult)
1544 {
1545  // Preconditions:
1546 
1547  // Body:
1548 
1549  xresult[0] = xjcb[0]*xother_jcb[0]+xjcb[2]*xother_jcb[2]+xjcb[4]*xother_jcb[4];
1550 
1551  xresult[1] =
1552  ( xjcb[0]*xother_jcb[1] + xjcb[2]*xother_jcb[3] + xjcb[4]*xother_jcb[5]
1553  + xjcb[1]*xother_jcb[0] + xjcb[3]*xother_jcb[2] + xjcb[5]*xother_jcb[4] )/2;
1554 
1555  xresult[2] = xjcb[1]*xother_jcb[1]+xjcb[3]*xother_jcb[3]+xjcb[5]*xother_jcb[5];
1556 
1557  // Postconditions:
1558 
1559  // Exit:
1560 }
1561 
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...
jcb_e23 & operator=(const row_dofs_type &xrdt)
Assignment to an instance of the associated row dofs type.
Definition: jcb_e23.cc:909
virtual bool is_contravariant(bool xauto_access) const
True if and only if all tensor index positions are contravariant.
Definition: tp.cc:1160
virtual const volatile_type & lite_prototype() const
Virtual constructor for the associated volatile type.
Definition: jcb_e23.cc:988
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 ...
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
static const poset_path & standard_schema_path()
The path to the standard schema for this class.
Definition: jcb_e23.cc:554
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
jcb_e23_lite & operator=(const jcb_e23_lite &xother)
Assignment operator.
Definition: jcb_e23.cc:80
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
row_dofs_type _row_dofs
Row_dofs_type.
Definition: jcb_e23.h:249
Euclidean vector space of dimension 2 (persistent version).
Definition: e2.h:405
Jacobian of a map from a 2 dimensional domain (u, v) to a 3 dimensional Euclidean space (x...
Definition: jcb_e23.h:421
int dd() const
The dimension of the underlying ("domain") vector space.
Definition: jcb_space.cc:248
poset_path path(bool xauto_access=true) const
A path to this component.
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.
static const std::string & static_class_name()
The name of this class.
Definition: jcb_e23.cc:426
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...
T components[6]
The dofs in the following order: components[0] => dx/du components[1] => dx/dv components[2] => dy/du...
Definition: jcb_e23.h:125
static void make_standard_schema(namespace_poset &xns)
Creates the standard schema for this class in namespace xns.
Definition: jcb_e23.cc:572
jcb_e23_row_dofs_type< double >::matrix_type matrix_type
The type of the associated matrix.
Definition: jcb_e23.h:161
virtual int dr() const
Dimension of the range.
Definition: jcb_e23.cc:353
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.
virtual bool is_ancestor_of(const any_lite &xother) const
Conformance test; true if other conforms to this.
Definition: jcb_e23.cc:478
SHEAF_DLL_SPEC void symmetric_dot_push(const jcb_e23_lite &xjcb, const jcb_e23_lite &xother_jcb, st2_e2_lite &xresult)
Transpose of xjcb times xother_jcb, symmetric part.
Definition: jcb_e23.cc:1541
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.
value_type component(int xindex) const
The xindex-th component.
Definition: vd.cc:209
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.
value_type component(int xrow, int xcolumn) const
The component with row index xrow and column index xcolumn.
Definition: jcb.cc:1037
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).
~jcb_e23()
Destructor.
Definition: jcb_e23.cc:975
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: jcb_e23.cc:1188
virtual const std::string & class_name() const
The name of this class.
Definition: jcb_e23.cc:407
virtual bool is_covariant(bool xauto_access) const
True if and only if all tensor index positions are covariant.
Definition: tp.cc:1078
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...
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
bool invariant() const
Class invariant.
Definition: jcb_e23.cc:497
virtual schema_poset_member & schema()
The schema for this poset (mutable version).
virtual volatile_type * lite_type() const
Virtual conversion to the associated volatile type.
Definition: jcb_e23.cc:1006
virtual void * row_dofs()
The row dofs for this instance (mutable version).
Definition: jcb_e23.cc:525
Euclidean vector space of dimension 2 (volatile version).
Definition: e2.h:112
static host_type & standard_host(namespace_type &xns, const std::string &xsuffix, bool xauto_access)
The host with path standard_host_path<jcbE_e23>(xsuffix). Returns the host if it already exists...
Definition: jcb_e23.cc:676
static const std::string & static_class_name()
The name of this class.
Definition: jcb_e23.cc:1134
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.
An index within the external ("client") scope of a given id space.
Definition: scoped_index.h:116
virtual jcb_e23_lite * clone() const
Virtual constructor, makes a new instance of the same type as this.
Definition: jcb_e23.cc:445
virtual int dd() const
Dimension of the domain.
Definition: jcb_e23.cc:333
virtual const std::string & class_name() const
The name of this class.
Definition: jcb_e23.cc:1115
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
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. ...
virtual value_type component(int xindex) const
The value of the xi-th component.
Definition: vd.cc:1115
SHEAF_DLL_SPEC void metric(const jcb_e23_lite &xjcb, st2_e2_lite &xresult)
Compute surface metric.
Definition: jcb_e23.cc:1522
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
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...
jcb_e23()
Default constructor.
Definition: jcb_e23.cc:751
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
poset_path domain_path() const
The path of the domain vector space.
Definition: jcb_space.cc:296
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.
virtual int dd() const
Dimension of the domain.
Definition: jcb.cc:831
poset_path scalar_space_path() const
The path of the underlying space of scalars.
Definition: vd_space.cc:250
Jacobian of a map from a 2 dimensional domain (u, v) to a 3 dimensional Euclidean space (x...
Definition: jcb_e23.h:142
bool invariant() const
Class invariant.
Definition: jcb_e23.cc:1214
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...
void put_component(int xindex, value_type xcomp)
Set the xindex-th component to xcomp.
Definition: vd.cc:230
An abstract vector space viewed as an antisymmetric tensor space of degree 1.
Definition: at1_space.h:42
static int d(const namespace_poset &xns, const poset_path &xschema_path, bool xauto_access)
The jacobian dimension implied by the schema specified by xschema_path.
Definition: jcb_space.cc:87
virtual void put_components(const value_type &dxdu, const value_type &dxdv, const value_type &dydu, const value_type &dydv, const value_type &dzdu, const value_type &dzdv)
Set values of the components to the given arguments.
Definition: jcb_e23.cc:280
poset_path range_path() const
The path of the range vector space.
Definition: jcb_space.cc:396
An abstract space of Jacobians.
Definition: jcb_space.h:46
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
jcb_e23_lite()
Default constructor.
Definition: jcb_e23.cc:48
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_e23.cc:608
virtual jcb_e23 * clone() const
Make a new handle, no state instance of current.
Definition: jcb_e23.cc:1153
virtual int d() const
Dimension of this as a vector space.
Definition: vd.cc:1017
A symmetric tensor of degree 2 over a Euclidean vector space of dimension 2 (volatile version)...
Definition: st2_e2.h:150
virtual int dr() const
Dimension of the range.
Definition: jcb_space.cc:348
virtual int dr() const
Dimension of the range.
Definition: jcb.cc:915
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
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
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
Namespace for the fiber_bundles component of the sheaf system.
virtual ~jcb_e23_lite()
Destructor.
Definition: jcb_e23.cc:103
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.
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