d6/d23/e3_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/e3.impl.h"

 #include "SheafSystem/abstract_poset_member.impl.h"
 #include "SheafSystem/assert_contract.h"
 #include "SheafSystem/at0.h"
 #include "SheafSystem/at0_space.h"
 #include "SheafSystem/at1_space.h"
 #include "SheafSystem/at2_e3.h"
 #include "SheafSystem/at3_e3.h"
 #include "SheafSystem/fiber_bundles_namespace.h"
 #include "SheafSystem/gl3.h"
 #include "SheafSystem/schema_poset_member.h"
 #include "SheafSystem/st2_e3.h"
 #include "SheafSystem/st3_e3.h"
 #include "SheafSystem/st4_e3.h"
 #include "SheafSystem/stp_space.h"
 #include "SheafSystem/t2_e3.h"
 #include "SheafSystem/t3_e3.h"
 #include "SheafSystem/t4_e3.h"
 #include "SheafSystem/tolerance_comparison.h"
 #include "SheafSystem/wsv_block.h"

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


 //==============================================================================
 // CLASS E3_LITE
 //==============================================================================

 //==============================================================================
 // EUCLIDEAN VECTOR ALGEBRA (E3) FACET OF CLASS E3_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::e3_lite::
 e3_lite()
 {

   // Preconditions:

   // Body:

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

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

   // Body:

   *this = xother;

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::e3_lite&
 fiber_bundle::e3_lite::
 operator=(const e3_lite& xother)
 {

   // Preconditions:

   // Body:

   if(this == &xother)
     return *this;

   _row_dofs = xother._row_dofs;

   // Postconditions:

   ensure(invariant());
   ensure(unexecutable(*this == xother));

   // Exit:

   return *this;
 }


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

   // Body:

   // Postconditions:

   // Exit:
 }

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

   // Body:

   *this = xrow_dofs;

   // Postconditions:

   // Exit:
 }

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

   // Body:

   _row_dofs = xrow_dofs;

   // Postconditions:

   ensure(invariant());
   ensure(unexecutable(row_dofs() == xrow_dofs));
   //ensure_for_all(i, 0, d(), component(i) == xrow_dofs[i]);

   // Exit:

   return *this;

 }

 fiber_bundle::e3_lite::
 e3_lite(const value_type& xvalue)
 {
   // Preconditions:

   // Body:

   _row_dofs.components[0] = xvalue;
   _row_dofs.components[1] = xvalue;
   _row_dofs.components[2] = xvalue;

   // Postconditions:

    ensure(invariant());
    ensure(isunordered_or_equals(component(0), xvalue));
    ensure(isunordered_or_equals(component(1), xvalue));
    ensure(isunordered_or_equals(component(2), xvalue));

   // Exit:
 }

 fiber_bundle::e3_lite::
 e3_lite(const value_type& x0, const value_type& x1, const value_type& x2)
 {
   // Preconditions:

   // Body:

   _row_dofs.components[0] = x0;
   _row_dofs.components[1] = x1;
   _row_dofs.components[2] = x2;

   // Postconditions:

    ensure(invariant());
    ensure(isunordered_or_equals(component(0), x0));
    ensure(isunordered_or_equals(component(1), x1));
    ensure(isunordered_or_equals(component(2), x2));

   // Exit:
 }

 fiber_bundle::e3_lite::
 operator e3_lite::row_dofs_type& ()
 {
   // Preconditions:

   // Body:

   row_dofs_type& result = _row_dofs;

   // Postconditions:

   ensure(invariant());

   // Exit:

   return result;
 }

 fiber_bundle::e3_lite::
 operator const e3_lite::row_dofs_type& () const
 {
   // Preconditions:

   // Body:

   const row_dofs_type& result = _row_dofs;

   // Postconditions:

   ensure(invariant());

   // Exit:

   return result;
 }

 void
 fiber_bundle::e3_lite::
 put_components(const value_type& x_comp,
                const value_type& y_comp,
                const value_type& z_comp)
 {
   // Preconditions:

   // Body:

   //   put_component(0, x_comp);
   //   put_component(1, y_comp);
   //   put_component(2, z_comp);

   _row_dofs.components[0] = x_comp;
   _row_dofs.components[1] = y_comp;
   _row_dofs.components[2] = z_comp;

   // Postconditions:

   ensure(invariant());
   ensure(isunordered_or_equals(component(0), x_comp));
   ensure(isunordered_or_equals(component(1), y_comp));
   ensure(isunordered_or_equals(component(2), z_comp));

   // Exit:
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // EUCLIDEAN VECTOR ALGEBRA (ED) FACET OF CLASS E3_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // EXTERIOR ALGEBRA (AT1) FACET OF CLASS E3_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

 int
 fiber_bundle::e3_lite::
 dd() const
 {
   // Preconditions:

   // Body:

   int result = 3;

   // Postconditions:

   ensure(invariant());
   ensure(result == 3);

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

 bool
 fiber_bundle::e3_lite::
 operator==(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3_lite::operator==." << endl;

   // Preconditions:

   // Body:

   bool result =
     (_row_dofs.components[0] == xother._row_dofs.components[0]) &&
     (_row_dofs.components[1] == xother._row_dofs.components[1]) &&
     (_row_dofs.components[2] == xother._row_dofs.components[2]);

   // Postconditions:


   // Exit:

   // cout << "Leaving e3_lite::operator==." << endl;
   return result;
 }

 fiber_bundle::e3_lite&
 fiber_bundle::e3_lite::
 operator=(const value_type& xvalue)
 {
   // Preconditions:

   // Body:

   _row_dofs.components[0] = xvalue;
   _row_dofs.components[1] = xvalue;
   _row_dofs.components[2] = xvalue;

   // Postconditions:

   ensure(invariant());
   ensure_for_all(i, 0, d(), component(i) == xvalue);

   // Exit:

   return *this;

 }

 bool
 fiber_bundle::e3_lite::
 operator==(const value_type& xvalue) const
 {
   // Preconditions:

   // Body:

   bool result =
     (_row_dofs.components[0] == xvalue) &&
     (_row_dofs.components[1] == xvalue) &&
     (_row_dofs.components[2] == xvalue);

   // Postconditions:

   ensure(invariant());
   ensure_for_all(i, 0, d(), !result || component(i) == xvalue);

   // Exit:

   return result;

 }

 const fiber_bundle::tp_lite&
 fiber_bundle::e3_lite::
 static_tp_prototype(int xp)
 {
   // Preconditions:

   require((0 <= xp) && (xp <= 4));

   // Body:

   switch(xp)
   {
     case 0:
       {
     static const at0_lite lat0_lite;
     return lat0_lite;
       }
     case 1:
       {
     static const e3_lite le3_lite;
     return le3_lite;
       }
     case 2:
       {
     static const t2_e3_lite lt2_e3_lite;
     return lt2_e3_lite;
       }
     case 3:
       {
     static const t3_e3_lite lt3_e3_lite;
     return lt3_e3_lite;
       }
     case 4:
       {
     static const t4_e3_lite lt4_e3_lite;
     return lt4_e3_lite;
       }
     default:
       {
     // Can't get here because of the precondition.
     static const tp_lite ltp_lite;
     return ltp_lite;
       }
   }

   // Postconditions:

   ensure(unexecutable("result.p() == xp"));

   // Exit:
 }

 const fiber_bundle::tp_lite&
 fiber_bundle::e3_lite::
 tp_prototype(int xp) const
 {
   // Preconditions:

   require(precondition_of(static_tp_prototype(xp)));

   // Body:

   const tp_lite& result = static_tp_prototype(xp);

   // Postconditions:

   ensure(postcondition_of(static_tp_prototype(xp)));

   // Exit:

   return result;
 }

 const fiber_bundle::atp_lite&
 fiber_bundle::e3_lite::
 static_atp_prototype(int xp)
 {
   // Preconditions:

   require((0 <= xp) && (xp <= 3));

   // Body:

   switch(xp)
   {
     case 0:
       {
     static const at0_lite lat0_lite;
     return lat0_lite;
       }
     case 1:
       {
     static const e3_lite le3_lite;
     return le3_lite;
       }
     case 2:
       {
     static const at2_e3_lite lat2_e3_lite;
     return lat2_e3_lite;
       }
     case 3:
       {
     static const at3_e3_lite lat3_e3_lite;
     return lat3_e3_lite;
       }
     default:
       {
     // Can't get here because of the precondition.
     static const atp_lite latp_lite;
     return latp_lite;
       }
   }

   // Postconditions:

   ensure(unexecutable("result.p() == xp"));

   // Exit:
 }

 const fiber_bundle::atp_lite&
 fiber_bundle::e3_lite::
 atp_prototype(int xp) const
 {
   // Preconditions:

   require(precondition_of(static_atp_prototype(xp)));

   // Body:

   const atp_lite& result = static_atp_prototype(xp);

   // Postconditions:

   ensure(postcondition_of(static_atp_prototype(xp)));

   // Exit:

   return result;
 }

 const fiber_bundle::stp_lite&
 fiber_bundle::e3_lite::
 static_stp_prototype(int xp)
 {
   // Preconditions:

   require((2 <= xp) && (xp <= 4));

   // Body:

   switch(xp)
   {
     case 2:
       {
     static const st2_e3_lite lst2_e3_lite;
     return lst2_e3_lite;
       }
     case 3:
       {
     static const st3_e3_lite lst3_e3_lite;
     return lst3_e3_lite;
       }
     case 4:
       {
     static const st4_e3_lite lst4_e3_lite;
     return lst4_e3_lite;
       }
     default:
       {
     // Can't get here because of the precondition.
     static const stp_lite lstp_lite;
     return lstp_lite;
       }
   }

   // Postconditions:

   ensure(unexecutable("result.p() == xp"));

   // Exit:
 }

 const fiber_bundle::stp_lite&
 fiber_bundle::e3_lite::
 stp_prototype(int xp) const
 {
   // Preconditions:

   require(precondition_of(static_stp_prototype(xp)));

   // Body:

   const stp_lite& result = static_stp_prototype(xp);

   // Postconditions:

   ensure(postcondition_of(static_stp_prototype(xp)));

   // Exit:

   return result;
 }


 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

 bool
 fiber_bundle::e3_lite::
 c_lt(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3::c_lt." << endl;

   // Preconditions:


   // Body:

   bool result =
     (_row_dofs.components[0] < xother._row_dofs.components[0]) &&
     (_row_dofs.components[1] < xother._row_dofs.components[1]) &&
     (_row_dofs.components[2] < xother._row_dofs.components[2]);


   // Postconditions:

   ensure(result == (((*this)[0] < xother[0]) && ((*this)[1] < xother[1]) && ((*this)[2] < xother[2])));

   // Exit:

   // cout << "Leaving e3::c_lt." << endl;
   return result;
 }

 bool
 fiber_bundle::e3_lite::
 c_le(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3::c_le." << endl;

   // Preconditions:


   // Body:

   bool result =
     (_row_dofs.components[0] <= xother._row_dofs.components[0]) &&
     (_row_dofs.components[1] <= xother._row_dofs.components[1]) &&
     (_row_dofs.components[2] <= xother._row_dofs.components[2]);


   // Postconditions:

   ensure(result == (((*this)[0] <= xother[0]) && ((*this)[1] <= xother[1]) && ((*this)[2] <= xother[2])));

   // Exit:

   // cout << "Leaving e3::c_le." << endl;
   return result;
 }

 bool
 fiber_bundle::e3_lite::
 c_gt(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3::c_gt." << endl;

   // Preconditions:


   // Body:

   bool result =
     (_row_dofs.components[0] > xother._row_dofs.components[0]) &&
     (_row_dofs.components[1] > xother._row_dofs.components[1]) &&
     (_row_dofs.components[2] > xother._row_dofs.components[2]);


   // Postconditions:

   ensure(result == (((*this)[0] > xother[0]) && ((*this)[1] > xother[1]) && ((*this)[2] > xother[2])));

   // Exit:

   // cout << "Leaving e3::c_gt." << endl;
   return result;
 }

 bool
 fiber_bundle::e3_lite::
 c_ge(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3::c_ge." << endl;

   // Preconditions:


   // Body:

   bool result =
     (_row_dofs.components[0] >= xother._row_dofs.components[0]) &&
     (_row_dofs.components[1] >= xother._row_dofs.components[1]) &&
     (_row_dofs.components[2] >= xother._row_dofs.components[2]);


   // Postconditions:

   ensure(result == (((*this)[0] >= xother[0]) && ((*this)[1] >= xother[1]) && ((*this)[2] >= xother[2])));

   // Exit:

   // cout << "Leaving e3::c_ge." << endl;
   return result;
 }

 bool
 fiber_bundle::e3_lite::
 d_lt(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3::d_lt." << endl;

   // Preconditions:


   // Body:

   bool result = false;

   if(_row_dofs.components[0] < xother._row_dofs.components[0])
   {
     result = true;
   }
   else
   {
     if(_row_dofs.components[0] == xother._row_dofs.components[0])
     {
       if(_row_dofs.components[1] < xother._row_dofs.components[1])
       {
     result = true;
       }
       else
       {
     if(_row_dofs.components[1] == xother._row_dofs.components[1])
     {
       if(_row_dofs.components[2] < xother._row_dofs.components[2])
       {
         result = true;
       }
     }
       }
     }
   }

   // Postconditions:


   // Exit:

   // cout << "Leaving e3::d_lt." << endl;
   return result;
 }

 bool
 fiber_bundle::e3_lite::
 d_le(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3::d_le." << endl;

   // Preconditions:


   // Body:

   bool result = false;

   if(_row_dofs.components[0] < xother._row_dofs.components[0])
   {
     result = true;
   }
   else
   {
     if(_row_dofs.components[0] == xother._row_dofs.components[0])
     {
       if(_row_dofs.components[1] < xother._row_dofs.components[1])
       {
     result = true;
       }
       else
       {
     if(_row_dofs.components[1] == xother._row_dofs.components[1])
     {
       if(_row_dofs.components[2] < xother._row_dofs.components[2])
       {
         result = true;
       }
       else
       {
         if(_row_dofs.components[2] == xother._row_dofs.components[2])
         {
           result = true;
         }
       }
     }
       }
     }
   }

   // Postconditions:


   // Exit:

   // cout << "Leaving e3::d_le." << endl;
   return result;
 }

 bool
 fiber_bundle::e3_lite::
 d_gt(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3::d_lt." << endl;

   // Preconditions:


   // Body:

   bool result = false;

   if(_row_dofs.components[0] > xother._row_dofs.components[0])
   {
     result = true;
   }
   else
   {
     if(_row_dofs.components[0] == xother._row_dofs.components[0])
     {
       if(_row_dofs.components[1] > xother._row_dofs.components[1])
       {
     result = true;
       }
       else
       {
     if(_row_dofs.components[1] == xother._row_dofs.components[1])
     {
       if(_row_dofs.components[2] > xother._row_dofs.components[2])
       {
         result = true;
       }
     }
       }
     }
   }

   // Postconditions:


   // Exit:

   // cout << "Leaving e3::d_gt." << endl;
   return result;
 }

 bool
 fiber_bundle::e3_lite::
 d_ge(const e3_lite& xother) const
 {
   // cout << endl << "Entering e3::d_ge." << endl;

   // Preconditions:


   // Body:

   bool result = false;

   if(_row_dofs.components[0] > xother._row_dofs.components[0])
   {
     result = true;
   }
   else
   {
     if(_row_dofs.components[0] == xother._row_dofs.components[0])
     {
       if(_row_dofs.components[1] > xother._row_dofs.components[1])
       {
     result = true;
       }
       else
       {
     if(_row_dofs.components[1] == xother._row_dofs.components[1])
     {
       if(_row_dofs.components[2] > xother._row_dofs.components[2])
       {
         result = true;
       }
       else
       {
         if(_row_dofs.components[2] == xother._row_dofs.components[2])
         {
           result = true;
         }
       }
     }
       }
     }
   }

   // Postconditions:


   // Exit:

   // cout << "Leaving e3::d_ge." << endl;
   return result;
 }


 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

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

   // Body:

   const string& result = static_class_name();

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

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

   // Body:

   static const string result("e3_lite");

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

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

   // Preconditions:

   // Body:

   result = new e3_lite();

   // Postconditions:

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

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ANY FACET OF CLASS E3_LITE
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 bool
 fiber_bundle::e3_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 e3_lite*>(&xother) != 0;

   // Postconditions:

   return result;
 }

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

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

     disable_invariant_check();

     // Must satisfy base class invariant.

     invariance(ed_lite::invariant());

     // Invariances for this class:

     // Finished, turn invariant checking back on.

     enable_invariant_check();
   }

   // Exit

   return result;
 }

 void*
 fiber_bundle::e3_lite::
 row_dofs()
 {
   return &_row_dofs;
 }

 const void*
 fiber_bundle::e3_lite::
 row_dofs() const
 {
   return &_row_dofs;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // CLASS E3
 //==============================================================================

 // ===========================================================
 // HOST FACTORY FACET OF CLASS E3
 // ===========================================================

 // PUBLIC MEMBER FUNCTIONS

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


   // Body:

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

   // Postconditions:

   // Exit:

   return result;
 }

 void
 fiber_bundle::e3::
 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:

   string lmember_names = "x DOUBLE false ";
   lmember_names       += "y DOUBLE false ";
   lmember_names       += "z DOUBLE false";

   schema_poset_member lschema(xns,
                               standard_schema_path().member_name(),
                               ed::standard_schema_path(),
                               lmember_names,
                               false);

   lschema.detach_from_state();

   // Postconditions:

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

   // Exit:

   return;
 }

 fiber_bundle::e3::host_type&
 fiber_bundle::e3::
 new_host(namespace_type& xns,
          const poset_path& xhost_path,
          const poset_path& xschema_path,
          const poset_path& xscalar_space_path,
          bool xauto_access)
 {
   // cout << endl << "Entering e3::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(schema_poset_member::row_dof_ct(xns, xschema_path, xauto_access) == 3);

   require(xns.path_is_auto_read_accessible(xscalar_space_path, xauto_access));
   require(xns.contains_poset<scalar_type::host_type>(xscalar_space_path, xauto_access));

   // Body:

   host_type& result =
     host_type::new_table(xns, xhost_path, xschema_path, xscalar_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) == 3);
   ensure(result.d(true) == 3);
   ensure(result.scalar_space_path(true) == xscalar_space_path );
   ensure(result.p(true) == 1);
   ensure(result.dd(true) == 3);
   ensure(result.vector_space_path(true) == xhost_path );

   // Exit:

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

 fiber_bundle::e3::host_type&
 fiber_bundle::e3::
 standard_host(namespace_type& xns, const std::string& xsuffix, bool xauto_access)
 {
   // cout << endl << "Entering e3::new_host." << endl;

   // Preconditions:

   require(xns.state_is_auto_read_write_accessible(xauto_access));

   require(xsuffix.empty() || poset_path::is_valid_name(xsuffix));
   require(standard_host_is_available<e3>(xns, xsuffix, xauto_access));

   require(xns.path_is_auto_read_accessible(standard_schema_path(), xauto_access));

   require(xns.path_is_auto_read_available(standard_host_path<scalar_type>(xsuffix), xauto_access));

   // Body:

   // Create the scalar space if necessary.

   poset_path lscalar_space_path = scalar_type::standard_host(xns, xsuffix, xauto_access).path(true);

   poset_path lpath(standard_host_path<e3>(xsuffix));

   host_type* result_ptr;
   if(xns.contains_path(lpath, xauto_access))
   {
     result_ptr = &xns.member_poset<host_type>(lpath, xauto_access);
   }
   else
   {
     result_ptr = &new_host(xns, lpath, standard_schema_path(), lscalar_space_path, xauto_access);
   }

   host_type& result = *result_ptr;

   // Postconditions:

   ensure(xns.owns(result, xauto_access));
   ensure(result.path(true) == standard_host_path<e3>(xsuffix));
   ensure(result.state_is_not_read_accessible());
   ensure(result.schema(true).path(xauto_access) == standard_schema_path());

   ensure(result.factor_ct(true) == 3);
   ensure(result.d(true) == 3);
   ensure(result.scalar_space_path(true) == standard_host_path<scalar_type>(xsuffix) );
   ensure(result.p(true) == 1);
   ensure(result.dd(true) == 3);
   ensure(result.vector_space_path(true) == result.path(true));

   // Exit:

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

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // EUCLIDEAN VECTOR ALGEBRA (E3) FACET OF CLASS E3
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::e3::
 e3()
 {
   // Preconditions:

   // Body:

   // Postconditions:

   ensure(invariant());

   // Exit:
 }

 fiber_bundle::e3::
 e3(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::e3::
 e3(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::e3::
 e3(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::e3::
 e3(abstract_poset_member* xother)
 {

   // Preconditions:

   require(xother != 0);

   // Body:

   attach_to_state(xother);

   // Postconditions:

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

   // Exit:

 }

 fiber_bundle::e3::
 e3(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::e3::
 e3(poset_state_handle& xhost,
        const row_dofs_type& xrdt,
        bool xauto_access)
 {

   // Preconditions:

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

   // Body:

   new_jim_state(&xhost, 0, false, xauto_access);

   if(xauto_access)
   {
     xhost.get_read_write_access();
   }

   *this = xrdt;

   if(xauto_access)
   {
     xhost.release_access();
   }

   // Postconditions:

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

   // Exit:

   return;
 }

 fiber_bundle::e3&
 fiber_bundle::e3::
 operator=(const row_dofs_type& xrdt)
 {
   // Preconditions:

   require(state_is_read_write_accessible());

   // Body:

   sheaf::row_dofs(*this) = xrdt;

   // Postconditions:

   ensure_for_all(i, 0, d(), component(i) == xrdt.components[i]);

   // Exit:

   return *this;

 }

 fiber_bundle::e3&
 fiber_bundle::e3::
 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::e3&
 fiber_bundle::e3::
 operator=(const e3& 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::e3::
 ~e3()
 {
   // Preconditions:

   // Body:

   // Postconditions:

 }

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

   // Body:

   static const volatile_type result;

   // Postconditions:

   // Exit:

   return result;
 }

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

   // Body:

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

   // Postconditions:

   // Exit:

   return result;
 }


 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // EUCLIDEAN VECTOR ALGEBRA (ED) FACET OF CLASS E3
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // EXTERIOR ALGEBRA (AT1) FACET OF CLASS E3
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

 void
 fiber_bundle::e3::
 put_components(dof_type xcomp, dof_type ycomp, dof_type zcomp)
 {
   // Preconditions:

   require(state_is_read_write_accessible());

   // Body:

   put_component(0, xcomp);
   put_component(1, ycomp);
   put_component(2, zcomp);

   // Postconditions:

   ensure(invariant());
   ensure(isunordered_or_equals(component(0), xcomp));
   ensure(isunordered_or_equals(component(1), ycomp));
   ensure(isunordered_or_equals(component(2), zcomp));

   // Exit:

   return;
 }

 fiber_bundle::e3::
 operator e3::row_dofs_type& ()
 {
   // Preconditions:

   // Body:

   row_dofs_type& result = sheaf::row_dofs(*this);

   // Postconditions:

   // Exit:

   return result;
 }

 fiber_bundle::e3::
 operator const e3::row_dofs_type& () const
 {
   // Preconditions:

   // Body:

   const row_dofs_type& result = sheaf::row_dofs(*this);

   // Postconditions:

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

 fiber_bundle::tp*
 fiber_bundle::e3::
 new_tp(tp_space& xvector_space, int xp)
 {
   // Preconditions:

   require(xvector_space.state_is_read_accessible());
   require((0 <= xp) && (xp <= 4));

   // Body:

   //============================================================================

   namespace_poset* lns = xvector_space.name_space();
   const string& lvector_space_name = xvector_space.name();

   switch(xp)
   {
     case 0:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "at0");
     at0::host_type& lhost = lns->member_poset<at0::host_type>(lname, false);
         at0* result = new at0(&lhost);
         return result;
       }

     case 1:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "e3");
     e3::host_type& lhost = lns->member_poset<e3::host_type>(lname, false);
         e3* result = new e3(&lhost);
         return result;
       }

     case 2:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "t2_e3");
     t2_e3::host_type& lhost = lns->member_poset<t2_e3::host_type>(lname, false);
         t2_e3* result = new t2_e3(&lhost);
         return result;
       }

     case 3:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "t3_e3");
     t3_e3::host_type& lhost = lns->member_poset<t3_e3::host_type>(lname, false);
         t3_e3* result = new t3_e3(&lhost);
         return result;
       }

     case 4:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "t4_e3");
     t4_e3::host_type& lhost = lns->member_poset<t4_e3::host_type>(lname, false);
         t4_e3* result = new t4_e3(&lhost);
         return result;
       }

     default:
       // Can't get here because of the precondition.
       return 0;

   }

   // Postconditions:

   ensure(unexecutable("result.p() == xp"));

   // Exit:
 }

 fiber_bundle::atp*
 fiber_bundle::e3::
 new_atp(tp_space& xvector_space, int xp)
 {
   // Preconditions:

   require(xvector_space.state_is_read_accessible());
   require((0 <= xp) && (xp <= 3));

   // Body:

   namespace_poset* lns = xvector_space.name_space();
   const string& lvector_space_name = xvector_space.name();

   switch(xp)
   {
     case 0:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "at0");
     at0::host_type& lhost = lns->member_poset<at0::host_type>(lname, false);
         at0* result = new at0(&lhost);
         return result;
       }

     case 1:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "e3");
     e3::host_type& lhost = lns->member_poset<e3::host_type>(lname, false);
         e3* result = new e3(&lhost);
         return result;
       }

     case 2:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "at2_e3");
     at2_e3::host_type& lhost = lns->member_poset<at2_e3::host_type>(lname, false);
         at2_e3* result = new at2_e3(&lhost);
         return result;
       }

     case 3:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "at3_e3");
     at3_e3::host_type& lhost = lns->member_poset<at3_e3::host_type>(lname, false);
         at3_e3* result = new at3_e3(&lhost);
         return result;
       }

     default:
       // Can't get here because of the precondition.
       return 0;
   }

   // Postconditions:

   ensure(unexecutable("result.p() == xp"));

   // Exit:
 }


 fiber_bundle::stp*
 fiber_bundle::e3::
 new_stp(tp_space& xvector_space, int xp)
 {
   // Preconditions:

   require(xvector_space.state_is_read_accessible());
   require((2 <= xp) && (xp <= 4));

   // Body:

   namespace_poset* lns = xvector_space.name_space();
   const string& lvector_space_name = xvector_space.name();

   switch(xp)
   {
     case 2:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "st2_e3");
         st2_e3::host_type& lhost = lns->member_poset<st2_e3::host_type>(lname, false);
         st2_e3* result = new st2_e3(&lhost);
         return result;
       }

     case 3:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "st3_e3");
         st3_e3::host_type& lhost = lns->member_poset<st3_e3::host_type>(lname, false);
         st3_e3* result = new st3_e3(&lhost);
         return result;
       }

     case 4:
       {
         const string lname =
           create_tensor_space_name(lvector_space_name, "st4_e3");
         st4_e3::host_type& lhost = lns->member_poset<st4_e3::host_type>(lname, false);
         st4_e3* result = new st4_e3(&lhost);
         return result;
       }

     default:
       // Can't get here because of the precondition.
       return 0;

   }

   // Postconditions:

   ensure(unexecutable("result.p() == xp"));

   // Exit:
 }

 fiber_bundle::tp*
 fiber_bundle::e3::
 new_tp(int xp, bool xauto_access) const
 {
   // Preconditions:

   require(precondition_of(e3::new_tp(vector_space(xauto_access), xp)));

   // Body:

   tp* result = e3::new_tp(vector_space(xauto_access), xp);

   // Postconditions:

   ensure(postcondition_of(e3::new_tp(vector_space(xauto_access), xp)));

   // Exit:

   return result;
 }

 fiber_bundle::atp*
 fiber_bundle::e3::
 new_atp(int xp, bool xauto_access) const
 {
   // Preconditions:

   require(precondition_of(e3::new_atp(vector_space(xauto_access), xp)));

   // Body:

   atp* result = e3::new_atp(vector_space(xauto_access), xp);

   // Postconditions:

   ensure(postcondition_of(e3::new_atp(vector_space(xauto_access), xp)));

   // Exit:

   return result;
 }

 fiber_bundle::stp*
 fiber_bundle::e3::
 new_stp(int xp, bool xauto_access) const
 {
   // Preconditions:

   require(precondition_of(e3::new_stp(vector_space(xauto_access), xp)));

   // Body:

   stp* result = e3::new_stp(vector_space(xauto_access), xp);

   // Postconditions:

   ensure(postcondition_of(e3::new_stp(vector_space(xauto_access), xp)));

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 // PUBLIC MEMBER FUNCTIONS

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

   // Body:

   const string& result = static_class_name();

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

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

   // Body:

   static const string result("e3");

   // Postconditions:

   ensure(!result.empty());

   // Exit:

   return result;
 }

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

   // Preconditions:

   // Body:

   // Create new handle of the current class.

   e3* result = new e3();

   // Postconditions:

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

   // Exit:

   return result;

 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


 //==============================================================================
 // ANY FACET OF CLASS E3
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 bool
 fiber_bundle::e3::
 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 e3*>(xother) != 0;

   // Postconditions:

   //  ensure(invariant());

   // Exit:

   return result;

 }

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

   // Preconditions:

   // Body:

   // Must satisfy base class invariant.

   invariance(ed::invariant());

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

     disable_invariant_check();

     invariance((is_attached() ? d() == 3 : true));

     // Finished, turn invariant checking back on.

     enable_invariant_check();
   }

   // Postconditions:

   ensure(is_derived_query);

   // Exit:

   return result;
 }

 // PROTECTED MEMBER FUNCTIONS

 // PRIVATE MEMBER FUNCTIONS


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

 size_t
 fiber_bundle::
 deep_size(const e3_lite& x0, bool xinclude_shallow)
 {
   size_t result;

   // Preconditions:

   // Body:


   result = 0;

   // Postconditions:

   ensure(result == 0);
   //ensure(result >= 0);

   // Exit

   return result;
 }

 //==============================================================================
 // E3 FACET:
 //==============================================================================

 // PUBLIC MEMBER FUNCTIONS

 void
 SHEAF_DLL_SPEC
 fiber_bundle::e3_algebra::
 cross(const e3& x0, const e3& x1, e3& 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.d(xauto_access) >= xresult.d(xauto_access));
   require(x1.d(xauto_access) >= xresult.d(xauto_access));
   require(x0.is_p_form(xauto_access) == x1.is_p_form(xauto_access));

   // Body:

   if(xauto_access)
   {
     x0.get_read_access();
     x1.get_read_access();
     xresult.get_read_write_access(true);
   }

   // Body:

   vd_value_type a0 = x0.component(0);
   vd_value_type a1 = x0.component(1);
   vd_value_type a2 = x0.component(2);

   vd_value_type b0 = x1.component(0);
   vd_value_type b1 = x1.component(1);
   vd_value_type b2 = x1.component(2);

   xresult.put_component(0, a1*b2 - a2*b1);
   xresult.put_component(1, a2*b0 - a0*b2);
   xresult.put_component(2, a0*b1 - a1*b0);

   // Set the variance of the result.

   x0.is_p_form(false) ? xresult.put_is_p_form(false)
                       : xresult.put_is_p_vector(false);

   if(xauto_access)
   {
     x0.release_access();
     x1.release_access();
     xresult.release_access();
   }

   // Postconditions:

   ensure(xresult.is_p_form(xauto_access) == x0.is_p_form(xauto_access));
   ensure(unexecutable("result == x0 cross x1"));

   // Exit:
 }

 void
 SHEAF_DLL_SPEC
 fiber_bundle::e3_algebra::
 cross_equal(e3& xresult, const e3& xother, bool xauto_access)
 {
   // Preconditions:

   require(precondition_of(cross(xresult, xother, xresult, xauto_access)));

   // Body:

   cross(xresult, xother, xresult, xauto_access);

   // Postconditions:

   ensure(postcondition_of(cross(xresult, xother, xresult, xauto_access)));

   // Exit:
 }


 fiber_bundle::e3_lite*
 fiber_bundle::e3_algebra::
 cross(const e3_lite& x0, const e3_lite& x1)
 {
   // Preconditions:

   // Body:

   e3_lite* result = x0.clone();
   cross(x0, x1, *result);

   // Postconditions:

   // Exit:

   return result;
 }

 void
 SHEAF_DLL_SPEC
 fiber_bundle::e3_algebra::
 cross(const e3_lite& x0, const e3_lite& x1, e3_lite& xresult)
 {
   // Preconditions:

   // Body:

   vd_value_type a0 = x0.component(0);
   vd_value_type a1 = x0.component(1);
   vd_value_type a2 = x0.component(2);

   vd_value_type b0 = x1.component(0);
   vd_value_type b1 = x1.component(1);
   vd_value_type b2 = x1.component(2);

   xresult.put_component(0, a1*b2 - a2*b1);
   xresult.put_component(1, a2*b0 - a0*b2);
   xresult.put_component(2, a0*b1 - a1*b0);

   // Postconditions:

   // Exit:
 }

 void
 fiber_bundle::e3_algebra::
 cross_equal(e3_lite& xresult, const e3_lite& xother)
 {
   // Preconditions:

   // Body:

   e3_lite x0 = xresult;
   cross(x0, xother, xresult);

   // Postconditions:

   // Exit:
 }

 fiber_bundle::e3_lite*
 fiber_bundle::e3_algebra::
 operator^(const e3_lite& x0, const e3_lite& x1)
 {
   // Preconditions:

   // Body:

   e3_lite* result = cross(x0, x1);

   // Postconditions:

   // Exit:

   return result;
 }

 fiber_bundle::e3_lite&
 fiber_bundle::e3_algebra::
 operator^=(e3_lite& xresult, const e3_lite& xother)
 {
   // Preconditions:

   // Body:

   cross_equal(xresult, xother);

   // Postconditions:

   // Exit:

   return xresult;
 }

 void
 fiber_bundle::vd_algebra::
 transform_basis_by(e3_lite& xv, const gl3_lite& xtransform, bool is_contravariant)
 {

   // Preconditions:

   require(xtransform.n() == xv.d());

   // Body:


   // Notation:
   //
   // Let the current basis be f-hat, considered as a row of vectors
   // with f-hat[i] the i-th basis vector. Similary, let e-hat be the
   // new basis. Let B be the matrix of the transform xtransform,
   // defined such that the i-th column, B[*][i] contains
   // the components of e-hat[i] with respect to f-hat.
   //
   // Given a covector V, let the components w.r.t. f-hat be represented
   // by a column vector, denoted Vf[k], where k is a row index.
   // Then the components w.r.t. e-hat are given by:
   //
   // Ve[m] = sum k{ B[k][m]*Vf[k] }
   //
   // For a (contravariant) vector, the transform is:
   //
   // Ve[m] = sum k{ C[m][k]*Vf[k] }
   //
   // where C is the inverse of B.

   // Get the row dof tuple

    e3_lite::value_type Ve[3];

   // Get the transform matrix


   //@todo Fix this when we can handle the variance.

   if(!is_contravariant)
   {
     // Covariant case.

     const gl3_lite::matrix_type& B = xtransform.basis_matrix();

     // Transform the components.

     for(int m=0; m<3; ++m)
     {
       Ve[m] = 0;
       for(int k=0; k<3; ++k)
       {
         Ve[m] += B[k][m]*xv[k];
       }
     }
   }
   else
   {
     // Contravariant case

     const gl3_lite::matrix_type& C = xtransform.component_matrix();

     // Transform the components.

     for(int m=0; m<3; ++m)
     {
       Ve[m] = 0;
       for(int k=0; k<3; ++k)
       {
         Ve[m] += C[m][k]*xv[k];
       }
     }
   }

   // Transfer the transformed components back onto the dof tuple.

   for(int i=0; i<3; ++i)
   {
     xv[i] = Ve[i];
   }

   // Postconditions:

   // Exit:

 }


 void
 fiber_bundle::vd_algebra::
 add(const e3_lite& x0, const e3_lite& x1, vd_value_type xt, e3_lite& xresult)
 {
   // Preconditions:

   require(x0.d() >= xresult.d());
   require(x1.d() >= xresult.d());

   // Body:

   vd_value_type lone_minus_t = 1.0 - xt;

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;
   e3_lite::row_dofs_type& lresult = xresult;

   lresult.components[0] = lx0.components[0]*lone_minus_t + lx1.components[0]*xt;
   lresult.components[1] = lx0.components[1]*lone_minus_t + lx1.components[1]*xt;
   lresult.components[2] = lx0.components[2]*lone_minus_t + lx1.components[2]*xt;

   // Postconditions:

   ensure(unexecutable("for_all: i, 0, xresult.d(), \
     xresult.component(i) == old_x0.component(i)*(1.0 - xt) + old_x1.component(i)*xt"));

   // Exit:

 }

 // ===========================================================
 // VECTOR ALGEBRA: TOLERANCE COMPARISON
 // ===========================================================


 bool
 fiber_bundle::vd_algebra::
 a_eql(const e3_lite& x0, const e3_lite& x1)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;

   bool result =
     sheaf::a_eql(lx0.components[0], lx1.components[0], double_tolerance) &&
     sheaf::a_eql(lx0.components[1], lx1.components[1], double_tolerance) &&
     sheaf::a_eql(lx0.components[2], lx1.components[2], double_tolerance);

   // Postconditions:

   // Exit:

   return result;
 };

 bool
 fiber_bundle::vd_algebra::
 a_eql(const e3_lite& x0, const e3_lite& x1, double xtolerance)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;

   bool result =
     sheaf::a_eql(lx0.components[0], lx1.components[0], xtolerance) &&
     sheaf::a_eql(lx0.components[1], lx1.components[1], xtolerance) &&
     sheaf::a_eql(lx0.components[2], lx1.components[2], xtolerance);

   // Postconditions:

   // Exit:

   return result;
 };

 bool
 fiber_bundle::vd_algebra::
 a_eql(const e3_lite& x0, const e3_lite& x1, const e3_lite& xtolerance)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;
   const e3_lite::row_dofs_type& lt = xtolerance;

   bool result =
     sheaf::a_eql(lx0.components[0], lx1.components[0], lt[0]) &&
     sheaf::a_eql(lx0.components[1], lx1.components[1], lt[1]) &&
     sheaf::a_eql(lx0.components[2], lx1.components[2], lt[2]);

   // Postconditions:

   // Exit:

   return result;
 };

 bool
 fiber_bundle::vd_algebra::
 r_eql(const e3_lite& x0, const e3_lite& x1)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;

   bool result =
     sheaf::r_eql(lx0.components[0], lx1.components[0], double_tolerance) &&
     sheaf::r_eql(lx0.components[1], lx1.components[1], double_tolerance) &&
     sheaf::r_eql(lx0.components[2], lx1.components[2], double_tolerance);

   // Postconditions:

   // Exit:

   return result;
 };

 bool
 fiber_bundle::vd_algebra::
 r_eql(const e3_lite& x0, const e3_lite& x1, double xtolerance)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;

   bool result =
     sheaf::r_eql(lx0.components[0], lx1.components[0], xtolerance) &&
     sheaf::r_eql(lx0.components[1], lx1.components[1], xtolerance) &&
     sheaf::r_eql(lx0.components[2], lx1.components[2], xtolerance);

   // Postconditions:

   // Exit:

   return result;
 };

 bool
 fiber_bundle::vd_algebra::
 r_eql(const e3_lite& x0, const e3_lite& x1, const e3_lite& xtolerance)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;
   const e3_lite::row_dofs_type& lt = xtolerance;

   bool result =
     sheaf::r_eql(lx0.components[0], lx1.components[0], lt[0]) &&
     sheaf::r_eql(lx0.components[1], lx1.components[1], lt[1]) &&
     sheaf::r_eql(lx0.components[2], lx1.components[2], lt[2]);

   // Postconditions:

   // Exit:

   return result;
 };

 bool
 fiber_bundle::vd_algebra::
 c_eql(const e3_lite& x0, const e3_lite& x1)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;

   bool result =
     sheaf::c_eql(lx0.components[0], lx1.components[0], double_tolerance) &&
     sheaf::c_eql(lx0.components[1], lx1.components[1], double_tolerance) &&
     sheaf::c_eql(lx0.components[2], lx1.components[2], double_tolerance);

   // Postconditions:

   // Exit:

   return result;
 };

 bool
 fiber_bundle::vd_algebra::
 c_eql(const e3_lite& x0, const e3_lite& x1, double xtolerance)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;

   bool result =
     sheaf::c_eql(lx0.components[0], lx1.components[0], xtolerance) &&
     sheaf::c_eql(lx0.components[1], lx1.components[1], xtolerance) &&
     sheaf::c_eql(lx0.components[2], lx1.components[2], xtolerance);

   // Postconditions:

   // Exit:

   return result;
 };

 bool
 fiber_bundle::vd_algebra::
 c_eql(const e3_lite& x0, const e3_lite& x1, const e3_lite& xtolerance)
 {
   // Preconditions:

   require(x0.d() == x1.d());

   // Body:

   const e3_lite::row_dofs_type& lx0 = x0;
   const e3_lite::row_dofs_type& lx1 = x1;
   const e3_lite::row_dofs_type& lt = xtolerance;

   bool result =
     sheaf::c_eql(lx0.components[0], lx1.components[0], lt[0]) &&
     sheaf::c_eql(lx0.components[1], lx1.components[1], lt[1]) &&
     sheaf::c_eql(lx0.components[2], lx1.components[2], lt[2]);

   // Postconditions:

   // Exit:

   return result;
 };

sheaf::poset_state_handle::get_read_write_access
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...
Definition: poset_state_handle.cc:399

fiber_bundle::gl3_lite::n
virtual int n() const
Dimension of the representation space; n in GL(n, R).
Definition: gl3.cc:671

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::gl3_lite::basis_matrix
matrix_type & basis_matrix()
The associated basis transformation matrix (non const version).
Definition: gl3.cc:254

fiber_bundle::vd_algebra::add
SHEAF_DLL_SPEC void add(const e3_lite &x0, const e3_lite &x1, vd_value_type xt, e3_lite &xresult)
Weighted sum x0*(1-xt) + x1*xt (pre-allocated version for volatile types).
Definition: e3.cc:2381

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

fiber_bundle::e3_lite::d_le
bool d_le(const e3_lite &xother) const
Dictionary (lexicographic) order less than or equal comparison.
Definition: e3.cc:786

fiber_bundle::stp
A symmetric tensor of degree p over an abstract vector space.
Definition: stp.h:190

fiber_bundle::vd_lite::value_type
vd_value_type value_type
The type of component in the fiber; the scalar type in the fiber vector space.
Definition: vd.h:129

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::e3::new_stp
static stp * new_stp(tp_space &xvector_space, int xp)
Static constructor for symmetric tensors of degree xp over vector space xvector_space.
Definition: e3.cc:1806

fiber_bundle::e3_lite::_row_dofs
row_dofs_type _row_dofs
Row_dofs_type.
Definition: e3.h:201

fiber_bundle::vd_algebra::r_eql
SHEAF_DLL_SPEC bool r_eql(const e3_lite &x0, const e3_lite &x1)
Relative equality comparison of e3_lite x0 to e3_lite x1 using tolerance double_tolerance.
Definition: e3.cc:2493

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_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::e3::make_standard_schema
static void make_standard_schema(namespace_poset &xns)
Creates the standard schema for this class in namespace xns.
Definition: e3.cc:1118

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

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

fiber_bundle::e3::new_tp
static tp * new_tp(tp_space &xvector_space, int xp)
Static constructor for general tensors of degree xp over vector space xvector_space.
Definition: e3.cc:1665

fiber_bundle::e3_lite::c_lt
bool c_lt(const e3_lite &xother) const
Cartesian order less than comparison.
Definition: e3.cc:631

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::e3_lite::row_dofs
virtual void * row_dofs()
The row dofs for this instance (mutable version).
Definition: e3.cc:1071

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::at1_lite
A general antisymmetric tensor of degree 1 over an abstract vector space (volatile version)...
Definition: at1.h:44

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

fiber_bundle::e3::invariant
bool invariant() const
Class invariant.
Definition: e3.cc:2035

fiber_bundle::st3_e3
A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version).
Definition: st3_e3.h:370

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

fiber_bundle::vd_lite::components
virtual void components(dof_type xresult[], int comps_dimension) const
The values of all the components (preallocated version).
Definition: vd.cc:252

std
STL namespace.

fiber_bundle::vd_lite::component
value_type component(int xindex) const
The xindex-th component.
Definition: vd.cc:209

fiber_bundle::t2_e3
A tensor of degree 2 over a Euclidean vector space of dimension 3 (persistent version).
Definition: t2_e3.h:457

fiber_bundle::e3_lite::~e3_lite
virtual ~e3_lite()
Destructor.
Definition: e3.cc:114

sheaf::poset_component::get_read_access
virtual void get_read_access() const
Get read access to the state associated with this.
Definition: poset_component.cc:1519

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::e3::new_atp
static atp * new_atp(tp_space &xvector_space, int xp)
Static constructor for antisymmetric tensors of degree xp over vector space xvector_space.
Definition: e3.cc:1741

fiber_bundle::st4_e3_lite
A symmetric rank 4 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: st4_e3.h:134

fiber_bundle::vd_algebra::transform_basis_by
SHEAF_DLL_SPEC void transform_basis_by(e3_lite &xv, const gl3_lite &xtransform, bool is_contravariant=true)
Transform the basis and components of xv by xtransform.
Definition: e3.cc:2283

fiber_bundle::e3_lite::is_ancestor_of
virtual bool is_ancestor_of(const any_lite &xother) const
Conformance test; true if other conforms to this.
Definition: e3.cc:1024

fiber_bundle::gl3_lite::component_matrix
matrix_type & component_matrix()
The associated component transformation matrix (non const version).
Definition: gl3.cc:288

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

fiber_bundle::e3_row_dofs_type::components
T components[3]
The components (row_dofs).
Definition: e3.h:101

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::t4_e3
A tensor of degree 4 over a Euclidean vector space of dimension 3 (persistent version).
Definition: t4_e3.h:438

fiber_bundle::e3::e3
e3()
Default constructor.
Definition: e3.cc:1268

fiber_bundle::e3_algebra::cross_equal
void SHEAF_DLL_SPEC cross_equal(e3 &xresult, const e3 &xother, bool xauto_access)
The 3D Euclidean vector "cross" product of xresult with xother (self-allocated version).
Definition: e3.cc:2169

fiber_bundle::e3_lite::e3_lite
e3_lite()
Default constructor.
Definition: e3.cc:58

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

fiber_bundle::tp
A general tensor of "degree" p and given "variance" over an abstract vector space.
Definition: tp.h:253

fiber_bundle::e3_lite::c_gt
bool c_gt(const e3_lite &xother) const
Cartesian order greater than comparison.
Definition: e3.cc:685

sheaf::poset_component::release_access
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...
Definition: poset_component.cc:1561

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::t3_e3_lite
A tensor of degree 3 over a Euclidean vector space of dimension 3 (volatile version).
Definition: t3_e3.h:151

fiber_bundle::e3_lite::operator==
bool operator==(const e3_lite &xother) const
True if this has the same components as xother.
Definition: e3.cc:344

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

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

sheaf::c_eql
SHEAF_DLL_SPEC bool c_eql(float xf0, float xf1)
Combined equality comparison of float xf0 to float xf1 using tolerance float_tolerance.
Definition: tolerance_comparison.h:115

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::vd_algebra::c_eql
SHEAF_DLL_SPEC bool c_eql(const e3_lite &x0, const e3_lite &x1)
Combined equality equality comparison of e3_lite x0 to e3_lite x1 using tolerance double_tolerance...
Definition: e3.cc:2569

fiber_bundle::e3_lite::static_class_name
static const std::string & static_class_name()
The name of this class.
Definition: e3.cc:972

fiber_bundle::at0_space
A space of scalars viewed as an antisymmetric tensor space of degree 0.
Definition: at0_space.h:42

fiber_bundle::e3::standard_host
static host_type & standard_host(namespace_type &xns, const std::string &xsuffix, bool xauto_access)
The host with path standard_host_path<e3>(xsuffix). Returns the host if it already exists...
Definition: e3.cc:1201

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::st2_e3_lite
A symmetric tensor of degree 2 over a Euclidean vector space of dimension 3 (volatile version)...
Definition: st2_e3.h:148

fiber_bundle::e3_lite::atp_prototype
virtual const atp_lite & atp_prototype(int xp) const
Prototype for antisymmetric tensors of degree xp over this vector space.
Definition: e3.cc:535

fiber_bundle::e3_lite::dd
virtual int dd() const
Dimension of the underlying vector space.
Definition: e3.cc:313

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::e3::~e3
~e3()
Destructor.
Definition: e3.cc:1493

sheaf::schema_poset_member::detach_from_state
virtual void detach_from_state()
Detach this handle from its state, if any.
Definition: schema_poset_member.cc:3753

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

fiber_bundle::t4_e3_lite
A tensor of degree 4 over a Euclidean vector space of dimension 3 (volatile version).
Definition: t4_e3.h:210

fiber_bundle::e3_lite::static_atp_prototype
static const atp_lite & static_atp_prototype(int xp)
Static prototype for antisymmetric tensors of degree xp over this vector space.
Definition: e3.cc:488

fiber_bundle::e3_lite::d_lt
bool d_lt(const e3_lite &xother) const
Dictionary (lexicographic) order less than comparison.
Definition: e3.cc:739

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::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::e3::lite_prototype
virtual const volatile_type & lite_prototype() const
Virtual constructor for the associated volatile type.
Definition: e3.cc:1505

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

sheaf::double_tolerance
const double double_tolerance
Tolerance for double comparisons.
Definition: tolerance_comparison.h:136

fiber_bundle::e3_lite::static_stp_prototype
static const stp_lite & static_stp_prototype(int xp)
Static prototype for symmetric tensors of degree xp over this vector space.
Definition: e3.cc:556

fiber_bundle::vd_algebra::a_eql
SHEAF_DLL_SPEC bool a_eql(const e3_lite &x0, const e3_lite &x1)
Absolute equality comparison of e3_lite x0 to e3_lite x1 using tolerance double_tolerance.
Definition: e3.cc:2417

fiber_bundle::vd::component
virtual value_type component(int xindex) const
The value of the xi-th component.
Definition: vd.cc:1115

fiber_bundle::gl3_lite::matrix_type
gl3_row_dofs_type< double >::matrix_type matrix_type
The type of the associated matrix.
Definition: gl3.h:202

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

sheaf::poset_state_handle::name
virtual std::string name() const
The name of this poset.
Definition: poset_state_handle.cc:1174

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

sheaf::poset_state_handle::release_access
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...
Definition: poset_state_handle.cc:425

fiber_bundle::e3_lite::class_name
virtual const std::string & class_name() const
The name of this class.
Definition: e3.cc:953

fiber_bundle::t2_e3_lite
A tensor of degree 2 over a Euclidean vector space of dimension 3 (volatile version).
Definition: t2_e3.h:151

fiber_bundle::e3_lite::tp_prototype
virtual const tp_lite & tp_prototype(int xp) const
Prototype for general tensors of degree xp over this vector space.
Definition: e3.cc:467

fiber_bundle::tp_lite
A general tensor of degree p over an abstract vector space (volatile version). Volatile version does ...
Definition: tp.h:59

fiber_bundle::gl3_lite
The mathematical group GL(3, R). The group of all invertible, linear transformations on the R3...
Definition: gl3.h:183

fiber_bundle::e3_lite::c_le
bool c_le(const e3_lite &xother) const
Cartesian order less than or equal comparison.
Definition: e3.cc:658

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

sheaf::namespace_poset::path_is_auto_read_available
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.
Definition: namespace_poset.cc:1174

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::e3_lite::d_gt
bool d_gt(const e3_lite &xother) const
Dictionary (lexicographic) order greater than comparison.
Definition: e3.cc:840

fiber_bundle::e3_lite::operator=
e3_lite & operator=(const e3_lite &xother)
Copy assignment operator.
Definition: e3.cc:90

fiber_bundle::e3::new_host
static host_type & new_host(namespace_type &xns, const poset_path &xhost_path, const poset_path &xschema_path, const poset_path &xscalar_space_path, bool xauto_access)
Creates a new host table for members of this type. The poset is created in namespace xns with path xh...
Definition: e3.cc:1151

sheaf::poset_state_handle::name_space
namespace_poset * name_space() const
The namespace this poset resides in.
Definition: poset_state_handle.cc:1127

fiber_bundle::e3_algebra::cross
void SHEAF_DLL_SPEC cross(const e3 &x0, const e3 &x1, e3 &xresult, bool xauto_access)
The 3D Euclidean vector "cross" product of x0 with x1 (pre-allocated version).
Definition: e3.cc:2112

sheaf::poset_component::get_read_write_access
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...
Definition: poset_component.cc:1539

fiber_bundle::vd_lite::put_component
void put_component(int xindex, value_type xcomp)
Set the xindex-th component to xcomp.
Definition: vd.cc:230

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

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

fiber_bundle::e3_lite::static_tp_prototype
static const tp_lite & static_tp_prototype(int xp)
Static prototype for general tensors of degree xp over this vector space.
Definition: e3.cc:415

fiber_bundle::e3_algebra::operator^
SHEAF_DLL_SPEC e3_lite * operator^(const e3_lite &x0, const e3_lite &x1)
The 3D Euclidean vector "cross" product of x0 with x1 (auto-allocated version).
Definition: e3.cc:2249

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

sheaf::r_eql
SHEAF_DLL_SPEC bool r_eql(float xf0, float xf1)
Relative equality comparison of float xf0 to float xf1 using tolerance float_tolerance.
Definition: tolerance_comparison.h:99

fiber_bundle::e3::is_ancestor_of
bool is_ancestor_of(const any *xother) const
True if other conforms to current.
Definition: e3.cc:2009

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

fiber_bundle::st3_e3_lite
A symmetric rank 3 tensor over a Euclidean vector space of dimension 3. (volatile version)...
Definition: st3_e3.h:118

fiber_bundle::st4_e3
A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version).
Definition: st4_e3.h:386

fiber_bundle::e3::put_components
virtual void put_components(dof_type x_comp, dof_type y_comp, dof_type z_comp)
Set values of the components to the given arguments.
Definition: e3.cc:1596

fiber_bundle::vd::d
virtual int d() const
Dimension of this as a vector space.
Definition: vd.cc:1017

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::e3::operator=
e3 & operator=(const row_dofs_type &xrdt)
Assignment to an instance of the associated row dofs type.
Definition: e3.cc:1427

sheaf::a_eql
SHEAF_DLL_SPEC bool a_eql(float xf0, float xf1)
Absolute equality comparison of float xf0 to float xf1 using tolerance float_tolerance.
Definition: tolerance_comparison.h:83

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

fiber_bundle::e3_lite::stp_prototype
virtual const stp_lite & stp_prototype(int xp) const
Prototype for symmetric tensors of degree xp over this vector space.
Definition: e3.cc:598

sheaf::poset_path::path
std::string path() const
The full path as a string.
Definition: poset_path.cc:450

fiber_bundle::vd::dof_type
vd_dof_type dof_type
The type of the degrees of freedom. Note that although dof_type == value_type in this implementation...
Definition: vd.h:431

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

fiber_bundle::vd::put_component
virtual void put_component(int xindex, value_type xvalue)
Sets the value of the xindex-th component to xvalue.
Definition: vd.cc:1169

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::tp_space
An abstract tensor space of degree p.
Definition: tp_space.h:47

fiber_bundle::stp_lite
A symmetric tensor of degree p over an abstract vector space (volatile version).
Definition: stp.h:44

fiber_bundle::e3_algebra::operator^=
SHEAF_DLL_SPEC e3_lite & operator^=(e3_lite &xresult, const e3_lite &xother)
The 3D Euclidean vector "cross" product of xresult with xother (pre-allocated version).
Definition: e3.cc:2266

fiber_bundle::e3_lite::c_ge
bool c_ge(const e3_lite &xother) const
Cartesian order greater than or equal comparison.
Definition: e3.cc:712

fiber_bundle::stp_space
An abstract symmetric tensor space of degree p.
Definition: stp_space.h:42

fiber_bundle::e3_lite::invariant
bool invariant() const
Class invariant.
Definition: e3.cc:1043

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

fiber_bundle::t3_e3
A tensor of degree 3 over a Euclidean vector space of dimension 3 (persistent version).
Definition: t3_e3.h:401

fiber_bundle::e3_lite::put_components
virtual void put_components(const value_type &x_comp, const value_type &y_comp, const value_type &z_comp)
Set values of the components to the given arguments.
Definition: e3.cc:241

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::vd_value_type
double vd_value_type
The type of component in the fiber; the scalar type in the fiber vector space.
Definition: fiber_bundle.h:63

fiber_bundle::e3_row_dofs_type< double >

fiber_bundle::st2_e3
A symmetric tensor of degree 2 over a Euclidean vector space of dimension 3 (persistent version)...
Definition: st2_e3.h:435

fiber_bundle::e3_lite::d_ge
bool d_ge(const e3_lite &xother) const
Dictionary (lexicographic) order greater than or equal comparison.
Definition: e3.cc:887

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

sheaf::isunordered_or_equals
SHEAF_DLL_SPEC bool isunordered_or_equals(float x1, float x2)
True if isunordered(x1, x2) or x1 == x2.
Definition: sheaf.cc:102