d2/d72/atp_8cc_source.html

 //
 // Copyright (c) 2014 Limit Point Systems, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //


 #include "SheafSystem/atp.h"

 #include "SheafSystem/abstract_poset_member.impl.h"
 #include "SheafSystem/assert_contract.h"
 #include "SheafSystem/at1.h"
 #include "SheafSystem/at1_space.h"
 #include "SheafSystem/atp_space.h"
 #include "SheafSystem/fiber_bundles_namespace.h"
 #include "SheafSystem/schema_poset_member.h"
 #include "SheafSystem/wsv_block.h"

 using namespace std;
 using namespace fiber_bundle; // Workaround for MS C++ bug.
 using namespace fiber_bundle::vd_algebra;

 //==============================================================================
 // CLASS ATP_LITE
 //==============================================================================

 //==============================================================================
 // EXTERIOR ALGEBRA (ATP) FACET OF CLASS ATP_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::atp_lite::
 atp_lite()
 {
   // Preconditions:

   // Body:

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::atp_lite::
 atp_lite(const atp_lite& xother)
 {
   // Preconditions:

   // Body:

   *this = xother;

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::atp_lite&
 fiber_bundle::atp_lite::
 operator=(const atp_lite& xother)
 {
   // Preconditions:

   // Body:

   // Postconditions:

   ensure(invariant());

   // Exit:

   return *this;
 }

 fiber_bundle::atp_lite::
 ~atp_lite()
 {
   // Preconditions:

   // Body:

   // Postconditions:

   // Exit:

 }

 fiber_bundle::atp_lite::
 atp_lite(const row_dofs_type& xrow_dofs)
 {
   // Preconditions:

   // Body:

   *this = xrow_dofs;

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::atp_lite&
 fiber_bundle::atp_lite::
 operator=(const row_dofs_type& xrow_dofs)
 {
   // Preconditions:

   // Body:

   vd_lite::operator=(xrow_dofs);

   // Postconditions:

   postcondition_of(vd_lite::operator=(xrow_dofs));

   // Exit:

   return *this;

 }

 //==============================================================================
 // TENSOR ALGEBRA (TP) FACET OF CLASS ATP_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // VECTOR ALGEBRA (VD) FACET OF CLASS ATP_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 int
 fiber_bundle::atp_lite::
 d() const
 {
   // Preconditions:

   //require(dd() >= p() && p() >= 0);

   // Body:

   //$$SCRIBBLE: Don't know what the correct value is here when
   //            dd() == 0 and p() == 1 (or 0).  For now just return 0.

   int result = 0;

   if(!(dd() == 0 && p() == 0))
   {
     if(dd() >= p() && p() >= 0)
     {
       result = static_cast<int>(binomial_coefficient(dd(), p()));
     }
   }

   // Postconditions:

   ensure(invariant());
   //ensure(result == static_cast<int>(binomial_coefficient(dd(), p())));

   // Exit:

   return result;

 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // CARTESIAN ALGEBRA (TUPLE) FACET OF CLASS ATP_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 const sheaf::poset_path&
 fiber_bundle::atp::
 standard_schema_path()
 {
   // Preconditions:


   // Body:

   static const poset_path result(standard_schema_poset_name(), "atp_schema");

   // Postconditions:

   ensure(result.full());
   ensure(result.poset_name() == standard_schema_poset_name());

   // Exit:

   return result;
 }

 void
 fiber_bundle::atp::
 make_standard_schema(namespace_poset& xns)
 {
   // Preconditions:

   require(xns.state_is_read_write_accessible());
   require(xns.contains_poset(standard_schema_poset_name()));
   require(!xns.contains_poset_member(standard_schema_path()));

   // Body:

   schema_poset_member lschema(xns,
                               standard_schema_path().member_name(),
                               tp::standard_schema_path(),
                               "",
                               false);

   lschema.detach_from_state();

   // Postconditions:

   ensure(xns.contains_poset_member(standard_schema_path()));

   // Exit:

   return;
 }

 fiber_bundle::atp::host_type&
 fiber_bundle::atp::
 new_host(namespace_type& xns,
          const poset_path& xhost_path,
          const poset_path& xschema_path,
      int xp,
          const poset_path& xvector_space_path,
          bool xauto_access)
 {
   // cout << endl << "Entering atp::new_host." << endl;

   // Preconditions:

   require(xns.state_is_auto_read_write_accessible(xauto_access));

   require(!xhost_path.empty());
   require(!xns.contains_path(xhost_path, xauto_access));

   require(xschema_path.full());
   require(xns.path_is_auto_read_accessible(xschema_path, xauto_access));
   require(schema_poset_member::conforms_to(xns, xschema_path, standard_schema_path()));

   require(xp >= 0);

   require(xns.path_is_auto_read_accessible(xvector_space_path, xauto_access));
   require(xns.contains_poset<vector_space_type::host_type>(xvector_space_path, xauto_access));

   require(host_type::d(xns, xschema_path, xauto_access) == host_type::d(xns, xp, xvector_space_path, xauto_access)); // dmb new

   // Body:

   host_type& result =
     host_type::new_table(xns, xhost_path, xschema_path, xp, xvector_space_path, xauto_access);

   // Postconditions:

   ensure(xns.owns(result, xauto_access));
   ensure(result.path(true) == xhost_path);
   ensure(result.state_is_not_read_accessible());
   ensure(result.schema(true).path(xauto_access) == xschema_path);

   ensure(result.factor_ct(true) == result.d(true));
   ensure(result.d(true) == host_type::d(xns, xschema_path, xauto_access));
   ensure(result.scalar_space_path(true) == xns.member_poset<vector_space_type::host_type>(xvector_space_path, xauto_access).scalar_space_path(xauto_access) );
   ensure(result.p(true) == xp);
   ensure(result.dd(true) == xns.member_poset<vector_space_type::host_type>(xvector_space_path, xauto_access).d());
   ensure(result.vector_space_path(true) == xvector_space_path );

   // Exit:

   // cout << "Leaving atp::new_host." << endl;
   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ABSTRACT POSET MEMBER FACET OF CLASS ATP_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 const std::string&
 fiber_bundle::atp_lite::
 class_name() const
 {
   // Preconditions:

   // Body:

   const string& result = static_class_name();

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

 const std::string&
 fiber_bundle::atp_lite::
 static_class_name()
 {
   // Preconditions:

   // Body:

   static const string result("atp_lite");

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

 fiber_bundle::atp_lite*
 fiber_bundle::atp_lite::
 clone() const
 {
   atp_lite* result = 0;

   // Preconditions:

   // Body:

   result = new atp_lite();

   // Postconditions:

   ensure(result != 0);
   ensure(is_same_type(*result));

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ANY FACET OF CLASS ATP_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 bool
 fiber_bundle::atp_lite::
 is_ancestor_of(const any_lite& xother) const
 {
   // Preconditions:

   require(&xother != 0);

   // Body:

   // True if other conforms to this.

   bool result = dynamic_cast<const atp_lite*>(&xother) != 0;

   // Postconditions:

   return result;
 }

 bool
 fiber_bundle::atp_lite::
 invariant() const
 {
   bool result = true;

   if(invariant_check())
   {
     // Prevent recursive calls to invariant.

     disable_invariant_check();

     // Must satisfy base class invariant.

     invariance(tp_lite::invariant());

     // Invariances for this class:

     // Finished, turn invariant checking back on.

     enable_invariant_check();
   }

   // Exit

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // CLASS ATP
 //==============================================================================

 // ===========================================================
 // HOST FACTORY FACET
 // ===========================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // EXTERIOR ALGEBRA (ATP) FACET OF CLASS ATP
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::atp::
 atp()
 {

   // Preconditions:

    // Body:

    // Postconditions:

   ensure(invariant());
 }

 fiber_bundle::atp::
 atp(const poset_state_handle* xhost, pod_index_type xhub_id)
 {
   // Preconditions:

   require(xhost != 0);
   require(xhost->state_is_read_accessible());
   require(xhost->contains_member(xhub_id));

   // Body:

   attach_to_state(xhost, xhub_id);

   // Postconditions:

   ensure(invariant());
   // ensure(host() == xhost);
   ensure(index() == xhub_id);
   ensure(is_attached());
 }

 fiber_bundle::atp::
 atp(const poset_state_handle* xhost, const scoped_index& xid)
 {
   // Preconditions:

   require(xhost != 0);
   require(xhost->state_is_read_accessible());
   require(xhost->contains_member(xid));

   // Body:

   attach_to_state(xhost, xid.hub_pod());

   // Postconditions:

   ensure(invariant());
   // ensure(host() == xhost);
   ensure(index() ==~ xid);
   ensure(is_attached());
 }

 fiber_bundle::atp::
 atp(const poset_state_handle* xhost, const std::string& xname)
 {

   // Preconditions:

   require(xhost != 0);
   require(xhost->state_is_read_accessible());
   require(!xname.empty());
   require(xhost->contains_member(xname));

   // Body:

   attach_to_state(xhost, xname);

   // Postconditions:

   ensure(invariant());
   // ensure(host() == xhost);
   ensure(name() == xname);
   ensure(is_attached());

 }

 fiber_bundle::atp::
 atp(abstract_poset_member* xother)
 {

   // Preconditions:

   require(xother != 0);

   // Body:

   attach_to_state(xother);

   // Postconditions:

   ensure(invariant());
   ensure(is_attached());
   ensure(is_same_state(xother));

 }

 fiber_bundle::atp::
 atp(poset_state_handle* xhost, bool xauto_access)
 {

   // Preconditions:

   require(precondition_of(new_jim_state(xhost, 0, false, xauto_access)));

   // Body:

   new_jim_state(xhost, 0, false, xauto_access);

   // Postconditions:

   ensure(postcondition_of(new_jim_state(xhost, 0, false, xauto_access)));

   // Exit:

   return;
 }

 fiber_bundle::atp&
 fiber_bundle::atp::
 operator=(const abstract_poset_member& xother)
 {
   // Preconditions:

   require(is_ancestor_of(&xother));
   require(precondition_of(attach_to_state(&xother)));

   // Body:

   attach_to_state(&xother);

   // Postconditions:

   ensure(postcondition_of(attach_to_state(&xother)));

   // Exit:

   return *this;
 }

 fiber_bundle::atp&
 fiber_bundle::atp::
 operator=(const atp& xother)
 {
   // Preconditions:

   require(precondition_of(attach_to_state(&xother)));

   // Body:

   attach_to_state(&xother);

   // Postconditions:

   ensure(postcondition_of(attach_to_state(&xother)));

   // Exit:

   return *this;
 }

 fiber_bundle::atp::
 ~atp()
 {

   // Preconditions:

   // Body:

   // Postconditions:

 }

 const fiber_bundle::atp::volatile_type&
 fiber_bundle::atp::
 lite_prototype() const
 {
   // Preconditions:

   // Body:

   static const volatile_type result;

   // Postconditions:

   // Exit:

   return result;
 }

 fiber_bundle::atp::volatile_type*
 fiber_bundle::atp::
 lite_type() const
 {
   // Preconditions:

   // Body:

   volatile_type* result = new volatile_type(sheaf::row_dofs(*this));

   // Postconditions:

   // Exit:

   return result;
 }

 bool
 fiber_bundle::atp::
 is_p_form(bool xauto_access) const
 {

   // Preconditions:

   require(state_is_auto_read_accessible(xauto_access));
   require(host()->contains_variance_subposets(xauto_access));

   // Body:

   bool result = host()->is_p_form(_index, xauto_access);

   // Postconditions:

   // Exit:

   return result;

 }

 void
 fiber_bundle::atp::
 put_is_p_form(bool xauto_access)
 {
   // Preconditions:

   require(state_is_auto_read_write_accessible(xauto_access));
   require(host()->contains_variance_subposets(xauto_access));

   // Body:

   host()->put_is_p_form(_index, xauto_access);

   // Postconditions:

   ensure(is_p_form(xauto_access));

   // Exit:

   return;
 }


 bool
 fiber_bundle::atp::
 is_p_vector(bool xauto_access) const
 {

   // Preconditions:

   require(state_is_auto_read_accessible(xauto_access));
   require(host()->contains_variance_subposets(xauto_access));

   // Body:

   bool result = host()->is_p_vector(_index, xauto_access);

   // Postconditions:

   // Exit:

   return result;
 }

 void
 fiber_bundle::atp::
 put_is_p_vector(bool xauto_access)
 {
   // Preconditions:

   require(state_is_auto_read_write_accessible(xauto_access));
   require(host()->contains_variance_subposets(xauto_access));

   // Body:

   host()->put_is_p_vector(_index, xauto_access);

   // Postconditions:

   ensure(is_p_vector(xauto_access));

   // Exit:

   return;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // TP FACET OF CLASS ATP
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // VD FACET OF CLASS ATP
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ABSTRACT POSET MEMBER FACET OF CLASS ATP
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 const std::string&
 fiber_bundle::atp::
 class_name() const
 {
   // Preconditions:

   // Body:

   const string& result = static_class_name();

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

 const std::string&
 fiber_bundle::atp::
 static_class_name()
 {
   // Preconditions:

   // Body:

   static const string result("atp");

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 // ===========================================================
 // POSET_COMPONENT FACET
 // ===========================================================

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::atp::host_type*
 fiber_bundle::atp::
 host() const
 {
   return reinterpret_cast<host_type*>(_host);
 }

 bool
 fiber_bundle::atp::
 host_is_ancestor_of(const poset_state_handle* xother) const
 {
   return dynamic_cast<const host_type*>(xother) != 0;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ANY FACET OF CLASS ATP
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 bool
 fiber_bundle::atp::
 is_ancestor_of(const any* xother) const
 {

   // Preconditions:

   require(xother != 0);

   // Body:

   // If other may be dynamically cast to the type of this then this is an
   // ancestor of other.

   bool result = dynamic_cast<const atp*>(xother) != 0;

   // Postconditions:

   //ensure(invariant());
   //ensure(other->invariant());

   // Exit:

   return result;

 }

 fiber_bundle::atp*
 fiber_bundle::atp::
 clone() const
 {

   // Preconditions:

   // Body:

   // Create new handle of the current class.

   atp* result = new atp();

   // Postconditions:

   ensure(result != 0);
   ensure(result->invariant());

   // Exit:

   return result;

 }

 bool
 fiber_bundle::atp::
 invariant() const
 {
   bool result = true;

   // Preconditions:

   // Body:

   // Must satisfy base class invariant.

   invariance(tp::invariant());

   if(invariant_check())
   {
     // Prevent recursive calls to invariant.

     disable_invariant_check();

     invariance(state_is_read_accessible() ? is_covariant(false) || is_contravariant(false) : true);

     // Finished, turn invariant checking back on.

     enable_invariant_check();
   }

   // Postconditions:

   ensure(is_derived_query);

   // Exit:

   return result;
 }

 //==============================================================================
 // NON-MEMBER FUNCTIONS
 //==============================================================================

 #include "SheafSystem/error_message.h"
 #include "SheafSystem/at0.h"
 #include "SheafSystem/e2.h"
 #include "SheafSystem/e3.h"
 #include "SheafSystem/at2_e2.h"
 #include "SheafSystem/at2_e3.h"
 #include "SheafSystem/at3_e3.h"

 void
 fiber_bundle::atp_algebra::
 hook(const atp& x0, const atp& x1, atp& xresult, bool xauto_access)
 {
   // Preconditions:

   require(x0.state_is_auto_read_accessible(xauto_access));
   require(x1.state_is_auto_read_accessible(xauto_access));
   require(xresult.state_is_auto_read_write_accessible(xauto_access));
   require(x0.is_p_form(xauto_access) == x1.is_p_form(xauto_access));
   require(x0.is_p_form(xauto_access) == xresult.is_p_form(xauto_access));

   // Body:

   const e2* e2_x0 = dynamic_cast<const e2*>(&x0);
   const e3* e3_x0 = dynamic_cast<const e3*>(&x0);
   const at2_e2* at2_e2_x0 = dynamic_cast<const at2_e2*>(&x0);
   const at2_e3* at2_e3_x0 = dynamic_cast<const at2_e3*>(&x0);
   const at3_e3* at3_e3_x0 = dynamic_cast<const at3_e3*>(&x0);

   const e2* e2_x1 = dynamic_cast<const e2*>(&x1);
   const e3* e3_x1 = dynamic_cast<const e3*>(&x1);

   at0* at0_xresult = dynamic_cast<at0*>(&xresult);
   e2* e2_xresult = dynamic_cast<e2*>(&xresult);
   e3* e3_xresult = dynamic_cast<e3*>(&xresult);
   at2_e3* at2_e3_xresult = dynamic_cast<at2_e3*>(&xresult);

   if(e2_x0 && e2_x1 && at0_xresult)
   {
     hook(*e2_x0, *e2_x1, *at0_xresult, xauto_access);
   }
   else if(at2_e2_x0 && e2_x1 && e2_xresult)
   {
     hook(*at2_e2_x0, *e2_x1, *e2_xresult, xauto_access);
   }
   else if(e3_x0 && e3_x1 && at0_xresult)
   {
     hook(*e3_x0, *e3_x1, *at0_xresult, xauto_access);
   }
   else if(at2_e3_x0 && e3_x1 && e3_xresult)
   {
     hook(*at2_e3_x0, *e3_x1, *e3_xresult, xauto_access);
   }
   else if(at3_e3_x0 && e3_x1 && at2_e3_xresult)
   {
     hook(*at3_e3_x0, *e3_x1, *at2_e3_xresult, xauto_access);
   }
   else
   {
     post_fatal_error_message(\
       "Unsupported argument types in call to hook(...)");
   }

   // Postconditions:


   //ensure();

   // Exit:

   return;

 }

 void
 fiber_bundle::atp_algebra::
 hook(const atp_lite& x0, const atp_lite& x1, atp_lite& xresult)
 {
   // Preconditions:

   // Body:

 // hook(const e2_lite& x0, const e2_lite& x1, at0_lite& xresult);
 // hook(const at2_e2_lite& x0, const e2_lite& x1, e2_lite& xresult);
 // hook(const e3_lite& x0, const e3_lite& x1, at0_lite& xresult);
 // hook(const at2_e3_lite& x0, const e3_lite& x1, e3_lite& xresult);
 // hook(const at3_e3_lite& x0, const e3_lite& x1, at2_e3_lite& xresult);

   const e2_lite* e2_x0 = dynamic_cast<const e2_lite*>(&x0);
   const e3_lite* e3_x0 = dynamic_cast<const e3_lite*>(&x0);
   const at2_e2_lite* at2_e2_x0 = dynamic_cast<const at2_e2_lite*>(&x0);
   const at2_e3_lite* at2_e3_x0 = dynamic_cast<const at2_e3_lite*>(&x0);
   const at3_e3_lite* at3_e3_x0 = dynamic_cast<const at3_e3_lite*>(&x0);

   const e2_lite* e2_x1 = dynamic_cast<const e2_lite*>(&x1);
   const e3_lite* e3_x1 = dynamic_cast<const e3_lite*>(&x1);

   at0_lite* at0_xresult = dynamic_cast<at0_lite*>(&xresult);
   e2_lite* e2_xresult = dynamic_cast<e2_lite*>(&xresult);
   e3_lite* e3_xresult = dynamic_cast<e3_lite*>(&xresult);
   at2_e3_lite* at2_e3_xresult = dynamic_cast<at2_e3_lite*>(&xresult);

   if(e2_x0 && e2_x1 && at0_xresult)
   {
     hook(*e2_x0, *e2_x1, *at0_xresult);
   }
   else if(at2_e2_x0 && e2_x1 && e2_xresult)
   {
     hook(*at2_e2_x0, *e2_x1, *e2_xresult);
   }
   else if(e3_x0 && e3_x1 && at0_xresult)
   {
     hook(*e3_x0, *e3_x1, *at0_xresult);
   }
   else if(at2_e3_x0 && e3_x1 && e3_xresult)
   {
     hook(*at2_e3_x0, *e3_x1, *e3_xresult);
   }
   else if(at3_e3_x0 && e3_x1 && at2_e3_xresult)
   {
     hook(*at3_e3_x0, *e3_x1, *at2_e3_xresult);
   }
   else
   {
     post_fatal_error_message(\
       "Unsupported argument types in call to hook(...)");
   }

   // Postconditions:


   //ensure();

   // Exit:

   return;

 }

 void
 fiber_bundle::atp_algebra::
 star(const atp& x0, atp& xresult, bool xauto_access)
 {
   // Preconditions:

   require(x0.state_is_auto_read_accessible(xauto_access));
   require(xresult.state_is_auto_read_write_accessible(xauto_access));
   require(x0.dd(xauto_access) == xresult.dd(xauto_access));

   // Body:

   const at2_e2* at2_e2_x0 = dynamic_cast<const at2_e2*>(&x0);
   const at0* at0_x0 = dynamic_cast<const at0*>(&x0);
   const e2* e2_x0 = dynamic_cast<const e2*>(&x0);
   const at2_e3* at2_e3_x0 = dynamic_cast<const at2_e3*>(&x0);
   const e3* e3_x0 = dynamic_cast<const e3*>(&x0);
   const at3_e3* at3_e3_x0 = dynamic_cast<const at3_e3*>(&x0);

   at0* at0_xresult = dynamic_cast<at0*>(&xresult);
   at2_e2* at2_e2_xresult = dynamic_cast<at2_e2*>(&xresult);
   e2* e2_xresult = dynamic_cast<e2*>(&xresult);
   e3* e3_xresult = dynamic_cast<e3*>(&xresult);
   at2_e3* at2_e3_xresult = dynamic_cast<at2_e3*>(&xresult);
   at3_e3* at3_e3_xresult = dynamic_cast<at3_e3*>(&xresult);

   if(at2_e2_x0 && at0_xresult)
   {
     star(*at2_e2_x0, *at0_xresult, xauto_access);
   }
   else if(at0_x0 && at2_e2_xresult)
   {
     star(*at0_x0, *at2_e2_xresult, xauto_access);
   }
   else if(e2_x0 && e2_xresult)
   {
     star(*e2_x0, *e2_xresult, xauto_access);
   }
   else if(at2_e3_x0 && e3_xresult)
   {
     star(*at2_e3_x0, *e3_xresult, xauto_access);
   }
   else if(e3_x0 && at2_e3_xresult)
   {
     star(*e3_x0, *at2_e3_xresult, xauto_access);
   }
   else if(at3_e3_x0 && at0_xresult)
   {
     star(*at3_e3_x0, *at0_xresult, xauto_access);
   }
   else if(at0_x0 && at3_e3_xresult)
   {
     star(*at0_x0, *at3_e3_xresult, xauto_access);
   }
   else
   {
     post_fatal_error_message(\
       "Unsupported argument types in call to star(...)");
   }

   // Postconditions:


   //ensure();

   // Exit:

   return;
 }

 void
 fiber_bundle::atp_algebra::
 star(const atp_lite& x0, atp_lite& xresult)
 {
   // Preconditions:

 //   require(x0.dd() == xresult.dd());

   // Body:

   const at2_e2_lite* at2_e2_x0 = dynamic_cast<const at2_e2_lite*>(&x0);
   const at0_lite* at0_x0 = dynamic_cast<const at0_lite*>(&x0);
   const e2_lite* e2_x0 = dynamic_cast<const e2_lite*>(&x0);
   const at2_e3_lite* at2_e3_x0 = dynamic_cast<const at2_e3_lite*>(&x0);
   const e3_lite* e3_x0 = dynamic_cast<const e3_lite*>(&x0);
   const at3_e3_lite* at3_e3_x0 = dynamic_cast<const at3_e3_lite*>(&x0);

   at0_lite* at0_xresult = dynamic_cast<at0_lite*>(&xresult);
   at2_e2_lite* at2_e2_xresult = dynamic_cast<at2_e2_lite*>(&xresult);
   e2_lite* e2_xresult = dynamic_cast<e2_lite*>(&xresult);
   e3_lite* e3_xresult = dynamic_cast<e3_lite*>(&xresult);
   at2_e3_lite* at2_e3_xresult = dynamic_cast<at2_e3_lite*>(&xresult);
   at3_e3_lite* at3_e3_xresult = dynamic_cast<at3_e3_lite*>(&xresult);

   if(at2_e2_x0 && at0_xresult)
   {
     star(*at2_e2_x0, *at0_xresult);
   }
   else if(at0_x0 && at2_e2_xresult)
   {
     star(*at0_x0, *at2_e2_xresult);
   }
   else if(e2_x0 && e2_xresult)
   {
     star(*e2_x0, *e2_xresult);
   }
   else if(at2_e3_x0 && e3_xresult)
   {
     star(*at2_e3_x0, *e3_xresult);
   }
   else if(e3_x0 && at2_e3_xresult)
   {
     star(*e3_x0, *at2_e3_xresult);
   }
   else if(at3_e3_x0 && at0_xresult)
   {
     star(*at3_e3_x0, *at0_xresult);
   }
   else if(at0_x0 && at3_e3_xresult)
   {
     star(*at0_x0, *at3_e3_xresult);
   }
   else
   {
     post_fatal_error_message(\
       "Unsupported argument types in call to star(...)");
   }

   // Postconditions:


   //ensure();

   // Exit:

   return;
 }

 fiber_bundle::atp_lite*
 fiber_bundle::atp_algebra::
 star(const atp_lite& x0)
 {
   // Preconditions:

   require(precondition_of(star(x0, *result)));

   // Body:

   atp_lite* result = new atp_lite();;

   star(x0, *result);

   // Postconditions:

   ensure(postcondition_of(star(x0, *result)));

   // Exit:

   return result;
 }

 void
 fiber_bundle::atp_algebra::
 wedge(const atp& x0, const atp& x1, atp& xresult, bool xauto_access)
 {
   // Preconditions:

   require(x0.state_is_auto_read_accessible(xauto_access));
   require(x1.state_is_auto_read_accessible(xauto_access));
   require(xresult.state_is_auto_read_write_accessible(xauto_access));
   require(x0.dd(xauto_access) >= xresult.dd(xauto_access));
   require(x1.dd(xauto_access) >= xresult.dd(xauto_access));
   require(xresult.p(xauto_access) == x0.p(xauto_access) + x1.p(xauto_access));

   // Body:

   const e2* e2_x0 = dynamic_cast<const e2*>(&x0);
   const e3* e3_x0 = dynamic_cast<const e3*>(&x0);
   const at2_e3* at2_e3_x0 = dynamic_cast<const at2_e3*>(&x0);

   const e2* e2_x1 = dynamic_cast<const e2*>(&x1);
   const e3* e3_x1 = dynamic_cast<const e3*>(&x1);

   at2_e2* at2_e2_xresult = dynamic_cast<at2_e2*>(&xresult);
   at2_e3* at2_e3_xresult = dynamic_cast<at2_e3*>(&xresult);
   at3_e3* at3_e3_xresult = dynamic_cast<at3_e3*>(&xresult);

   if(e2_x0 && e2_x1 && at2_e2_xresult)
   {
     wedge(*e2_x0, *e2_x1, *at2_e2_xresult, xauto_access);
   }
   else if(e3_x0 && e3_x1 && at2_e3_xresult)
   {
     wedge(*e3_x0, *e3_x1, *at2_e3_xresult, xauto_access);
   }
   else if(at2_e3_x0 && e3_x1 && at3_e3_xresult)
   {
     wedge(*at2_e3_x0, *e3_x1, *at3_e3_xresult, xauto_access);
   }
   else
   {
     post_fatal_error_message(\
       "Unsupported argument types in call to wedge(...)");
   }

   // Postconditions:


   //ensure();

   // Exit:

   return;
 }

 void
 fiber_bundle::atp_algebra::
 wedge(const atp_lite& x0, const atp_lite& x1, atp_lite& xresult)
 {
   // Preconditions:

   require(x0.dd() == x1.dd());
   require(x0.dd() == xresult.dd());
   require(xresult.p() == x0.p() + x1.p());

   // Body:

   //wedge(const e2_lite& x0, const e2_lite& x1, at2_e2_lite& xresult);
   //wedge(const e3_lite& x0, const e3_lite& x1, at2_e3_lite& xresult);
   //wedge(const at2_e3_lite& x0, const e3_lite& x1, at3_e3_lite& xresult);

   const e2_lite* e2_x0 = dynamic_cast<const e2_lite*>(&x0);
   const e3_lite* e3_x0 = dynamic_cast<const e3_lite*>(&x0);
   const at2_e3_lite* at2_e3_x0 = dynamic_cast<const at2_e3_lite*>(&x0);

   const e2_lite* e2_x1 = dynamic_cast<const e2_lite*>(&x1);
   const e3_lite* e3_x1 = dynamic_cast<const e3_lite*>(&x1);

   at2_e2_lite* at2_e2_xresult = dynamic_cast<at2_e2_lite*>(&xresult);
   at2_e3_lite* at2_e3_xresult = dynamic_cast<at2_e3_lite*>(&xresult);
   at3_e3_lite* at3_e3_xresult = dynamic_cast<at3_e3_lite*>(&xresult);

   if(e2_x0 && e2_x1 && at2_e2_xresult)
   {
     wedge(*e2_x0, *e2_x1, *at2_e2_xresult);
   }
   else if(e3_x0 && e3_x1 && at2_e3_xresult)
   {
     wedge(*e3_x0, *e3_x1, *at2_e3_xresult);
   }
   else if(at2_e3_x0 && e3_x1 && at3_e3_xresult)
   {
     wedge(*at2_e3_x0, *e3_x1, *at3_e3_xresult);
   }
   else
   {
     post_fatal_error_message(\
       "Unsupported argument types in call to hook(...)");
   }

   // Postconditions:


   //ensure();

   // Exit:

   return;
 }
fiber_bundle::tp_lite::dd
virtual int dd() const
Dimension of the underlying vector space.
Definition: tp.cc:166

fiber_bundle::atp_lite::operator=
atp_lite & operator=(const atp_lite &xother)
Assignment operator.
Definition: atp.cc:78

sheaf::poset_state_handle::path
virtual poset_path path(bool xauto_access=true) const
The path of this poset.
Definition: poset_state_handle.cc:1241

sheaf::read_write_monitor_handle::state_is_auto_read_write_accessible
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 ...
Definition: read_write_monitor_handle.cc:387

fiber_bundle::tp::dd
virtual int dd() const
Dimension of the underlying vector space.
Definition: tp.cc:788

sheaf::poset_path::full
bool full() const
True if both poset name and member name are not empty.
Definition: poset_path.cc:311

fiber_bundle::tp::p
virtual int p() const
The degree of the tensors in host(); the sum of the contravariant and covariant degrees.
Definition: tp.cc:735

fiber_bundle::at2_e2
An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 2 (persistent version)...
Definition: at2_e2.h:412

fiber_bundle::atp
An antisymmetric tensor of degree p.
Definition: atp.h:190

fiber_bundle::atp::put_is_p_vector
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

fiber_bundle::e3_lite
Euclidean vector space of dimension 3 (volatile version).
Definition: e3.h:116

fiber_bundle::atp::static_class_name
static const std::string & static_class_name()
The name of this class.
Definition: atp.cc:817

fiber_bundle::atp_space::d
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

fiber_bundle::atp::new_host
static host_type & new_host(namespace_type &xns, const poset_path &xhost_path, const poset_path &xschema_path, int xp, 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: atp.cc:256

fiber_bundle::atp::~atp
virtual ~atp()
Destructor.
Definition: atp.cc:629

fiber_bundle::e2
Euclidean vector space of dimension 2 (persistent version).
Definition: e2.h:405

fiber_bundle::at3_e3_lite
An antisymmetric rank 3 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: at3_e3.h:120

sheaf::poset_component::path
poset_path path(bool xauto_access=true) const
A path to this component.
Definition: poset_component.cc:787

fiber_bundle::at2_e3
An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 3. (persistent version)...
Definition: at2_e3.h:424

fiber_bundle::atp_lite::~atp_lite
virtual ~atp_lite()
Destructor.
Definition: atp.cc:94

sheaf::namespace_poset
The default name space; a poset which contains other posets as members.
Definition: namespace_poset.h:68

sheaf::read_write_monitor_handle::state_is_read_accessible
bool state_is_read_accessible() const
True if this is attached and if the state is accessible for read or access control is disabled...
Definition: read_write_monitor_handle.cc:244

sheaf::namespace_poset::path_is_auto_read_accessible
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.
Definition: namespace_poset.cc:1127

fiber_bundle::fiber_bundles_namespace
The standard fiber bundles name space; extends the standard sheaves namespace by defining base space...
Definition: fiber_bundles_namespace.h:53

fiber_bundle::tp_space::vector_space_path
poset_path vector_space_path() const
The path of the underlying vector space.
Definition: tp_space.cc:365

fiber_bundle::atp::host_is_ancestor_of
virtual bool host_is_ancestor_of(const poset_state_handle *other) const
True if other conforms to host.
Definition: atp.cc:854

sheaf::namespace_poset::contains_poset_member
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...
Definition: namespace_poset.cc:425

sheaf::read_write_monitor_handle::state_is_auto_read_accessible
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...
Definition: read_write_monitor_handle.cc:309

sheaf::poset_state_handle
A client handle for a general, abstract partially order set.
Definition: poset_state_handle.h:136

sheaf::poset_path
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

std
STL namespace.

fiber_bundle::atp::is_ancestor_of
bool is_ancestor_of(const any *xother) const
True if xother conforms to current.
Definition: atp.cc:872

sheaf::namespace_poset::member_poset
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.
Definition: namespace_poset.cc:601

fiber_bundle::vd_algebra::binomial_coefficient
SHEAF_DLL_SPEC unsigned int binomial_coefficient(unsigned int xi, unsigned int xj)
Binomial coefficient (xi, xj).
Definition: vd.cc:2673

fiber_bundle::atp::host
host_type * host() const
The poset this is a member of.
Definition: atp.cc:847

fiber_bundle::atp_lite::invariant
bool invariant() const
Class invariant.
Definition: atp.cc:411

fiber_bundle::at2_e2_lite
An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 2 (volatile version)...
Definition: at2_e2.h:146

fiber_bundle::e3
Euclidean vector space of dimension 3 (persistent version).
Definition: e3.h:467

sheaf::row_dofs
T::row_dofs_type & row_dofs(T &x0)
The row dofs pod type for x0 (mutable version).
Definition: abstract_poset_member.impl.h:130

fiber_bundle::tp_lite::p
virtual int p() const
The degree of the tensor; the sum of the contravariant and covariant degrees.
Definition: tp.cc:146

fiber_bundle::atp_lite
An antisymmetric tensor of degree p over an abstract vector space (volatile version).
Definition: atp.h:44

fiber_bundle::any_lite
Abstract base class with useful features for all volatile objects.
Definition: any_lite.h:48

fiber_bundle::at3_e3
An antisymmetric rank 3 tensor over a 3D Euclidean vector space.
Definition: at3_e3.h:372

sheaf::any
Abstract base class with useful features for all objects.
Definition: any.h:39

fiber_bundle::atp_algebra::wedge
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

fiber_bundle::atp_algebra::hook
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

fiber_bundle::atp_lite::static_class_name
static const std::string & static_class_name()
The name of this class.
Definition: atp.cc:340

sheaf::poset_state_handle::schema
virtual schema_poset_member & schema()
The schema for this poset (mutable version).
Definition: poset_state_handle.cc:6212

fiber_bundle::atp::operator=
virtual atp & operator=(const abstract_poset_member &xother)
Assignment operator; synonym for attach_to_state(&xother).
Definition: atp.cc:586

fiber_bundle::atp_lite::is_ancestor_of
virtual bool is_ancestor_of(const any_lite &xother) const
Conformance test; true if other conforms to this.
Definition: atp.cc:392

fiber_bundle::e2_lite
Euclidean vector space of dimension 2 (volatile version).
Definition: e2.h:112

fiber_bundle::atp_space
An abstract antisymmetric tensor space of degree p.
Definition: atp_space.h:42

sheaf::read_write_monitor_handle::state_is_read_write_accessible
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...
Definition: read_write_monitor_handle.cc:333

fiber_bundle::atp_lite::atp_lite
atp_lite()
Default constructor.
Definition: atp.cc:47

sheaf::namespace_poset::owns
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)
Definition: namespace_poset.cc:404

fiber_bundle::atp::atp
atp()
Default constructor.
Definition: atp.cc:464

sheaf::scoped_index
An index within the external ("client") scope of a given id space.
Definition: scoped_index.h:116

fiber_bundle::atp::invariant
bool invariant() const
Class invariant.
Definition: atp.cc:923

fiber_bundle::at0
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

sheaf::poset_path::poset_name
std::string poset_name() const
The poset name part of the path.
Definition: poset_path.cc:473

fiber_bundle::atp_lite::class_name
virtual const std::string & class_name() const
The name of this class.
Definition: atp.cc:321

sheaf::namespace_poset::contains_path
bool contains_path(const poset_path &xpath, bool xauto_access=true) const
True if this contains the poset or poset member specified by xpath.
Definition: namespace_poset.cc:1095

fiber_bundle::atp::is_p_form
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

fiber_bundle::at0_lite
Antisymetric tensor of degree 0 (volatile version).
Definition: at0.h:127

sheaf::poset_state_handle::contains_member
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. ...
Definition: poset_state_handle.cc:1776

fiber_bundle::tp_space::p
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

fiber_bundle::atp_lite::d
virtual int d() const
Dimension of this as a vector space.
Definition: atp.cc:161

sheaf::poset_path::empty
bool empty() const
True if both poset name and member name are empty.
Definition: poset_path.cc:291

fiber_bundle::atp::class_name
virtual const std::string & class_name() const
The name of this class.
Definition: atp.cc:798

sheaf::namespace_poset::contains_poset
bool contains_poset(pod_index_type xhub_id, bool xauto_access=true) const
True if this contains a poset with hub id xhub_id..
Definition: namespace_poset.cc:326

fiber_bundle::vd_space::scalar_space_path
poset_path scalar_space_path() const
The path of the underlying space of scalars.
Definition: vd_space.cc:250

fiber_bundle::at1_space
An abstract vector space viewed as an antisymmetric tensor space of degree 1.
Definition: at1_space.h:42

fiber_bundle::atp_lite::clone
virtual atp_lite * clone() const
Virtual constructor, makes a new instance of the same type as this.
Definition: atp.cc:359

fiber_bundle::vd_space::factor_ct
static int factor_ct(int xd)
Factor_ct() as a function of dimension xd.
Definition: vd_space.cc:167

sheaf::pod_index_type
int_type pod_index_type
The plain old data index type.
Definition: pod_types.h:49

fiber_bundle::tp_space::dd
int dd() const
The dimension of the underlying ("domain") vector space.
Definition: tp_space.cc:317

fiber_bundle::atp::lite_type
virtual volatile_type * lite_type() const
Virtual conversion to the associated volatile type.
Definition: atp.cc:660

fiber_bundle::atp::is_p_vector
bool is_p_vector(bool xauto_access) const
True if this is a p-vector; synonym for is_contravariant(xauto_access).
Definition: atp.cc:722

fiber_bundle::at2_e3_lite
An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: at2_e3.h:142

fiber_bundle::atp::clone
virtual atp * clone() const
Make a new handle, no state instance of current.
Definition: atp.cc:899

fiber_bundle::atp::make_standard_schema
static void make_standard_schema(namespace_poset &xns)
Creates the standard schema for this class in namespace xns.
Definition: atp.cc:227

sheaf::abstract_poset_member
An abstract client handle for a member of a poset.
Definition: abstract_poset_member.h:164

fiber_bundle::atp::put_is_p_form
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

fiber_bundle::vd_algebra
Namespace containing the vector algrebra functions for the fiber_bundles component of the sheaf syste...
Definition: e3.h:1135

fiber_bundle
Namespace for the fiber_bundles component of the sheaf system.
Definition: base_space_crg_interval.h:36

fiber_bundle::atp::lite_prototype
virtual const volatile_type & lite_prototype() const
Virtual constructor for the associated volatile type.
Definition: atp.cc:642

fiber_bundle::vd_row_dofs_type
Row dofs type for class vd.
Definition: vd.h:61

fiber_bundle::atp_algebra::star
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

sheaf::read_write_monitor_handle::state_is_not_read_accessible
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...
Definition: read_write_monitor_handle.cc:276

sheaf::schema_poset_member
A client handle for a poset member which has been prepared for use as a schema.
Definition: schema_poset_member.h:75

fiber_bundle::atp::standard_schema_path
static const poset_path & standard_schema_path()
The path to the standard schema for this class.
Definition: atp.cc:206

sheaf::scoped_index::hub_pod
pod_type hub_pod() const
The pod value of this mapped to the unglued hub id space.
Definition: scoped_index.h:710