diff --git a/Index_8h.html b/Index_8h.html new file mode 100644 index 0000000..4a6cfbc --- /dev/null +++ b/Index_8h.html @@ -0,0 +1,132 @@ + + + + + symtensor/Index.h file | symtensor + + + + + + + + + + + + + +
+
+
+
+
+

+ symtensor/Index.h file +

+

Index types and convenience functions for working with indices.

+ +
+

Namespaces

+
+
namespace symtensor
+
+
+
+
+
+
+
+ + + + + + diff --git a/MultipoleBase_8h.html b/MultipoleBase_8h.html new file mode 100644 index 0000000..f752931 --- /dev/null +++ b/MultipoleBase_8h.html @@ -0,0 +1,158 @@ + + + + + symtensor/MultipoleBase.h file | symtensor + + + + + + + + + + + + + +
+
+
+
+
+

+ symtensor/MultipoleBase.h file +

+

Provides the base multipole template.

+ +
+

Namespaces

+
+
namespace symtensor
+
+
+
+
+

Classes

+
+
+
template<class Implementation, typename ... Tensors>
+ class symtensor::MultipoleBase +
+
Multipole base-type for use with CRTP implementations.
+
+
template<typename Implementation, typename Tuple>
+ class symtensor::MultipoleBaseFromTuple +
+
Helper class for defining a multipole based on an std::tuple of tensors.
+
+
template<symtensor::derived_from_template<symtensor::MultipoleBase> T>
+ struct std::tuple_size<T> +
+
tuple-size specialization to enable the use of structured bindings with multipoles
+
+
template<std::size_t I, symtensor::derived_from_template<symtensor::MultipoleBase> T>
+ struct std::tuple_element<I, T> +
+
tuple-element specialization to enable the use of structured bindings with multipoles
+
+
+
+
+
+
+ + + + + + diff --git a/Multipole_8h.html b/Multipole_8h.html index 53f401e..cab344c 100644 --- a/Multipole_8h.html +++ b/Multipole_8h.html @@ -31,9 +31,10 @@
  1. Pages
  2. +
  3. Namespaces
  4. Classes
-
    +
    1. Files
    2. diff --git a/SymmetricTensorBase_8h.html b/SymmetricTensorBase_8h.html index 4571438..9487a18 100644 --- a/SymmetricTensorBase_8h.html +++ b/SymmetricTensorBase_8h.html @@ -31,9 +31,10 @@
      1. Pages
      2. +
      3. Namespaces
      4. Classes
      -
        +
        1. Files
        2. diff --git a/SymmetricTensor_8h.html b/SymmetricTensor_8h.html index a5c9225..cf87de8 100644 --- a/SymmetricTensor_8h.html +++ b/SymmetricTensor_8h.html @@ -31,9 +31,10 @@
          1. Pages
          2. +
          3. Namespaces
          4. Classes
          -
            +
            1. Files
            2. diff --git a/annotated.html b/annotated.html index 0904926..a7e7cb0 100644 --- a/annotated.html +++ b/annotated.html @@ -31,9 +31,10 @@
              1. Pages
              2. +
              3. Namespaces
              4. Classes
              -
                +
                1. Files
                2. @@ -63,6 +64,7 @@

                  Classes

                  diff --git a/classsymtensor_1_1Multipole.html b/classsymtensor_1_1Multipole.html index 5cd1eac..509fa67 100644 --- a/classsymtensor_1_1Multipole.html +++ b/classsymtensor_1_1Multipole.html @@ -31,9 +31,10 @@
                  1. Pages
                  2. +
                  3. Namespaces
                  4. Classes
                  -
                    +
                    1. Files
                    2. @@ -77,6 +78,847 @@

                      + +
                      +

                      Base classes

                      +
                      +
                      +
                      template<typename Implementation, typename Tuple>
                      + class MultipoleBaseFromTuple<Multipole<Order, Tensors...>, TensorSequence<Order, Tensors...>> +
                      +
                      Helper class for defining a multipole based on an std::tuple of tensors.
                      +
                      +
                      +
                      +

                      Public types

                      +
                      +
                      + using TensorTuple = std::tuple<Tensors...> +
                      +
                      +
                      +
                      +
                      +

                      Public static variables

                      +
                      +
                      + static std::size_t Order constexpr +
                      +
                      +
                      + static std::size_t NumTensors constexpr +
                      +
                      +
                      +
                      +
                      +

                      Member access

                      +
                      +
                      +
                      template<std::size_t R>
                      + auto tensor() const -> const auto& constexpr +
                      +
                      Tensor access by rank.
                      +
                      +
                      template<std::size_t R>
                      + auto tensor() -> auto& constexpr +
                      +
                      Tensor access by rank.
                      +
                      +
                      +
                      +

                      Multipole-scalar operations

                      +
                      +
                      +
                      template<typename T>
                      + auto operator+=(const T& scalar) -> Implementation& constexpr +
                      +
                      Element-wise addition of a scalar.
                      +
                      +
                      template<typename T>
                      + auto operator-=(const T& scalar) -> Implementation& constexpr +
                      +
                      Element-wise subtraction of a scalar.
                      +
                      +
                      template<typename T>
                      + auto operator*=(const T& scalar) -> Implementation& constexpr +
                      +
                      Element-wise multiplication by a scalar.
                      +
                      +
                      template<typename T>
                      + auto operator/=(const T& scalar) -> Implementation& constexpr +
                      +
                      Element-wise division by a scalar.
                      +
                      +
                      template<typename T>
                      + auto operator+(const T& scalar) const -> Implementation constexpr +
                      +
                      Element-wise addition of a scalar.
                      +
                      +
                      template<typename T>
                      + auto operator-(const T& scalar) const -> Implementation constexpr +
                      +
                      Element-wise subtraction of a scalar.
                      +
                      +
                      template<typename T>
                      + auto operator*(const T& scalar) const -> Implementation constexpr +
                      +
                      Element-wise multiplication by a scalar.
                      +
                      +
                      template<typename T>
                      + auto operator/(const T& scalar) const -> Implementation constexpr +
                      +
                      Element-wise division by a scalar.
                      +
                      +
                      +
                      +

                      Multipole-multipole operations

                      +
                      +
                      + auto operator+=(const Implementation& other) -> Implementation& constexpr +
                      +
                      Element-wise addition with another multipole.
                      +
                      + auto operator-=(const Implementation& other) -> Implementation& constexpr +
                      +
                      Element-wise subtraction by another multipole.
                      +
                      + auto operator*=(const Implementation& other) -> Implementation& constexpr +
                      +
                      Element-wise multiplication by another multipole.
                      +
                      + auto operator/=(const Implementation& other) -> Implementation& constexpr +
                      +
                      Element-wise division by another multipole.
                      +
                      + auto operator+(const Implementation& other) const -> Implementation constexpr +
                      +
                      Element-wise addition with another multipole.
                      +
                      + auto operator-(const Implementation& other) const -> Implementation constexpr +
                      +
                      Element-wise subtraction by another multipole.
                      +
                      + auto operator*(const Implementation& other) const -> Implementation constexpr +
                      +
                      Element-wise multiplication by another multipole.
                      +
                      + auto operator/(const Implementation& other) const -> Implementation constexpr +
                      +
                      Element-wise division by another multipole.
                      +
                      +
                      +
                      +

                      Comparison operators

                      +
                      +
                      + auto operator==(const Self& other) const -> bool defaulted constexpr +
                      +
                      Comparison with another multipole.
                      +
                      +
                      +
                      +

                      std::tuple compatibility

                      +
                      +
                      + auto underlying_tuple() const -> const TensorTuple& constexpr +
                      +
                      direct access to the tuple of tensors which comprises the multipole
                      +
                      +
                      template<std::size_t I>
                      + auto get() & -> auto& constexpr +
                      +
                      element access for use with structured bindings
                      +
                      +
                      template<std::size_t I>
                      + auto get() const & -> const auto& constexpr +
                      +
                      element access for use with structured bindings
                      +
                      +
                      template<std::size_t I>
                      + auto get() && -> auto&& constexpr +
                      +
                      element access for use with structured bindings
                      +
                      +
                      +
                      +

                      Typedef documentation

                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + using symtensor::Multipole<Order, Tensors>::TensorTuple = std::tuple<Tensors...> +

                      +
                      +
                      +
                      +

                      Function documentation

                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<std::size_t R> +
                      + const auto& symtensor::Multipole<Order, Tensors>::tensor() const constexpr +

                      +

                      Tensor access by rank.

                      + + + + + + + + + + + + + + + + +
                      Template parameters
                      RRank of the tensor to retrieve
                      Returnsreference to the tensor with the requested rank
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<std::size_t R> +
                      + auto& symtensor::Multipole<Order, Tensors>::tensor() constexpr +

                      +

                      Tensor access by rank.

                      + + + + + + + + + + + + + + + + +
                      Template parameters
                      RRank of the tensor to retrieve
                      Returnsreference to the tensor with the requested rank
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<typename T> +
                      + Implementation& symtensor::Multipole<Order, Tensors>::operator+=(const T& scalar) constexpr +

                      +

                      Element-wise addition of a scalar.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      scalarvalue to add to each tensor of the multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<typename T> +
                      + Implementation& symtensor::Multipole<Order, Tensors>::operator-=(const T& scalar) constexpr +

                      +

                      Element-wise subtraction of a scalar.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      scalarvalue to subtract from each tensor of the multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<typename T> +
                      + Implementation& symtensor::Multipole<Order, Tensors>::operator*=(const T& scalar) constexpr +

                      +

                      Element-wise multiplication by a scalar.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      scalarvalue to multiply each tensor of the multipole by.
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<typename T> +
                      + Implementation& symtensor::Multipole<Order, Tensors>::operator/=(const T& scalar) constexpr +

                      +

                      Element-wise division by a scalar.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      scalarvalue to divide each element of the multipole by.
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<typename T> +
                      + Implementation symtensor::Multipole<Order, Tensors>::operator+(const T& scalar) const constexpr +

                      +

                      Element-wise addition of a scalar.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      scalarvalue to add to each tensor of the multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<typename T> +
                      + Implementation symtensor::Multipole<Order, Tensors>::operator-(const T& scalar) const constexpr +

                      +

                      Element-wise subtraction of a scalar.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      scalarvalue to subtract from each tensor of the multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<typename T> +
                      + Implementation symtensor::Multipole<Order, Tensors>::operator*(const T& scalar) const constexpr +

                      +

                      Element-wise multiplication by a scalar.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      scalarvalue to multiply each tensor of the multipole by.
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<typename T> +
                      + Implementation symtensor::Multipole<Order, Tensors>::operator/(const T& scalar) const constexpr +

                      +

                      Element-wise division by a scalar.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      scalarvalue to divide each element of the multipole by.
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + Implementation& symtensor::Multipole<Order, Tensors>::operator+=(const Implementation& other) constexpr +

                      +

                      Element-wise addition with another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to add with this multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + Implementation& symtensor::Multipole<Order, Tensors>::operator-=(const Implementation& other) constexpr +

                      +

                      Element-wise subtraction by another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to subtract from this multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + Implementation& symtensor::Multipole<Order, Tensors>::operator*=(const Implementation& other) constexpr +

                      +

                      Element-wise multiplication by another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to multiply with this multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + Implementation& symtensor::Multipole<Order, Tensors>::operator/=(const Implementation& other) constexpr +

                      +

                      Element-wise division by another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to divide this multipole by
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + Implementation symtensor::Multipole<Order, Tensors>::operator+(const Implementation& other) const constexpr +

                      +

                      Element-wise addition with another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to add with this multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + Implementation symtensor::Multipole<Order, Tensors>::operator-(const Implementation& other) const constexpr +

                      +

                      Element-wise subtraction by another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to subtract from this multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + Implementation symtensor::Multipole<Order, Tensors>::operator*(const Implementation& other) const constexpr +

                      +

                      Element-wise multiplication by another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to multiply with this multipole
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + Implementation symtensor::Multipole<Order, Tensors>::operator/(const Implementation& other) const constexpr +

                      +

                      Element-wise division by another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to divide this multipole by
                      Returnsthe modified multipole
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + bool symtensor::Multipole<Order, Tensors>::operator==(const Self& other) const defaulted constexpr +

                      +

                      Comparison with another multipole.

                      + + + + + + + + + + + + + + + + +
                      Parameters
                      othermultipole to compare with
                      Returnstrue if all elements of the multipoles are equivalent, false otherwise
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + const TensorTuple& symtensor::Multipole<Order, Tensors>::underlying_tuple() const constexpr +

                      +

                      direct access to the tuple of tensors which comprises the multipole

                      + + + + + + + +
                      Returnsreference to the std::tuple of tensors.
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<std::size_t I> +
                      + auto& symtensor::Multipole<Order, Tensors>::get() & constexpr +

                      +

                      element access for use with structured bindings

                      + + + + + + + + + + + + + + + + +
                      Template parameters
                      Iindex of the element to retrieve (not necessarily the same as Rank)
                      Returnsreference to the tensor
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<std::size_t I> +
                      + const auto& symtensor::Multipole<Order, Tensors>::get() const & constexpr +

                      +

                      element access for use with structured bindings

                      + + + + + + + + + + + + + + + + +
                      Template parameters
                      Iindex of the element to retrieve (not necessarily the same as Rank)
                      Returnsreference to the tensor
                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> + template<std::size_t I> +
                      + auto&& symtensor::Multipole<Order, Tensors>::get() && constexpr +

                      +

                      element access for use with structured bindings

                      + + + + + + + + + + + + + + + + +
                      Template parameters
                      Iindex of the element to retrieve (not necessarily the same as Rank)
                      Returnsreference to the tensor
                      +
                      +
                      +
                      +

                      Variable documentation

                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + static std::size_t symtensor::Multipole<Order, Tensors>::Order constexpr +

                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... Tensors> +
                      + static std::size_t symtensor::Multipole<Order, Tensors>::NumTensors constexpr +

                      +
                      +

          diff --git a/classsymtensor_1_1MultipoleBase.html b/classsymtensor_1_1MultipoleBase.html index a2ce9f0..5596c11 100644 --- a/classsymtensor_1_1MultipoleBase.html +++ b/classsymtensor_1_1MultipoleBase.html @@ -31,9 +31,10 @@
          1. Pages
          2. +
          3. Namespaces
          4. Classes
          -
            +
            1. Files
            2. @@ -57,6 +58,7 @@

              +
              template<class Implementation, typename ... Tensors>
              symtensor::MultipoleBase class

              @@ -82,14 +84,28 @@

              Contents

            3. Reference
            4. In order to create a new type which behaves like a multipole, you can derive from this class so that operators will function correctly.

              +
              +

              Derived classes

              +
              +
              +
              template<typename Implementation, typename Tuple>
              + class MultipoleBaseFromTuple +
              +
              Helper class for defining a multipole based on an std::tuple of tensors.
              +
              +

              Constructors

              @@ -163,6 +179,76 @@

              Multipole-scalar operations

              Element-wise division by a scalar.
              +
              +

              Multipole-multipole operations

              +
              +
              + auto operator+=(const Implementation& other) -> Implementation& constexpr +
              +
              Element-wise addition with another multipole.
              +
              + auto operator-=(const Implementation& other) -> Implementation& constexpr +
              +
              Element-wise subtraction by another multipole.
              +
              + auto operator*=(const Implementation& other) -> Implementation& constexpr +
              +
              Element-wise multiplication by another multipole.
              +
              + auto operator/=(const Implementation& other) -> Implementation& constexpr +
              +
              Element-wise division by another multipole.
              +
              + auto operator+(const Implementation& other) const -> Implementation constexpr +
              +
              Element-wise addition with another multipole.
              +
              + auto operator-(const Implementation& other) const -> Implementation constexpr +
              +
              Element-wise subtraction by another multipole.
              +
              + auto operator*(const Implementation& other) const -> Implementation constexpr +
              +
              Element-wise multiplication by another multipole.
              +
              + auto operator/(const Implementation& other) const -> Implementation constexpr +
              +
              Element-wise division by another multipole.
              +
              +
              +
              +

              Comparison operators

              +
              +
              + auto operator==(const Self& other) const -> bool defaulted constexpr +
              +
              Comparison with another multipole.
              +
              +
              +
              +

              std::tuple compatibility

              +
              +
              + auto underlying_tuple() const -> const TensorTuple& constexpr +
              +
              direct access to the tuple of tensors which comprises the multipole
              +
              +
              template<std::size_t I>
              + auto get() & -> auto& constexpr +
              +
              element access for use with structured bindings
              +
              +
              template<std::size_t I>
              + auto get() const & -> const auto& constexpr +
              +
              element access for use with structured bindings
              +
              +
              template<std::size_t I>
              + auto get() && -> auto&& constexpr +
              +
              element access for use with structured bindings
              +
              +

              Function documentation

              @@ -465,6 +551,338 @@

              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + Implementation& symtensor::MultipoleBase<Implementation, Tensors>::operator+=(const Implementation& other) constexpr +

              +

              Element-wise addition with another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to add with this multipole
              Returnsthe modified multipole
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + Implementation& symtensor::MultipoleBase<Implementation, Tensors>::operator-=(const Implementation& other) constexpr +

              +

              Element-wise subtraction by another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to subtract from this multipole
              Returnsthe modified multipole
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + Implementation& symtensor::MultipoleBase<Implementation, Tensors>::operator*=(const Implementation& other) constexpr +

              +

              Element-wise multiplication by another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to multiply with this multipole
              Returnsthe modified multipole
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + Implementation& symtensor::MultipoleBase<Implementation, Tensors>::operator/=(const Implementation& other) constexpr +

              +

              Element-wise division by another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to divide this multipole by
              Returnsthe modified multipole
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + Implementation symtensor::MultipoleBase<Implementation, Tensors>::operator+(const Implementation& other) const constexpr +

              +

              Element-wise addition with another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to add with this multipole
              Returnsthe modified multipole
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + Implementation symtensor::MultipoleBase<Implementation, Tensors>::operator-(const Implementation& other) const constexpr +

              +

              Element-wise subtraction by another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to subtract from this multipole
              Returnsthe modified multipole
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + Implementation symtensor::MultipoleBase<Implementation, Tensors>::operator*(const Implementation& other) const constexpr +

              +

              Element-wise multiplication by another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to multiply with this multipole
              Returnsthe modified multipole
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + Implementation symtensor::MultipoleBase<Implementation, Tensors>::operator/(const Implementation& other) const constexpr +

              +

              Element-wise division by another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to divide this multipole by
              Returnsthe modified multipole
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + bool symtensor::MultipoleBase<Implementation, Tensors>::operator==(const Self& other) const defaulted constexpr +

              +

              Comparison with another multipole.

              + + + + + + + + + + + + + + + + +
              Parameters
              othermultipole to compare with
              Returnstrue if all elements of the multipoles are equivalent, false otherwise
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> +
              + const TensorTuple& symtensor::MultipoleBase<Implementation, Tensors>::underlying_tuple() const constexpr +

              +

              direct access to the tuple of tensors which comprises the multipole

              + + + + + + + +
              Returnsreference to the std::tuple of tensors.
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> + template<std::size_t I> +
              + auto& symtensor::MultipoleBase<Implementation, Tensors>::get() & constexpr +

              +

              element access for use with structured bindings

              + + + + + + + + + + + + + + + + +
              Template parameters
              Iindex of the element to retrieve (not necessarily the same as Rank)
              Returnsreference to the tensor
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> + template<std::size_t I> +
              + const auto& symtensor::MultipoleBase<Implementation, Tensors>::get() const & constexpr +

              +

              element access for use with structured bindings

              + + + + + + + + + + + + + + + + +
              Template parameters
              Iindex of the element to retrieve (not necessarily the same as Rank)
              Returnsreference to the tensor
              +
              +
              +

              +
              + template<class Implementation, typename ... Tensors> + template<std::size_t I> +
              + auto&& symtensor::MultipoleBase<Implementation, Tensors>::get() && constexpr +

              +

              element access for use with structured bindings

              + + + + + + + + + + + + + + + + +
              Template parameters
              Iindex of the element to retrieve (not necessarily the same as Rank)
              Returnsreference to the tensor
              +
      diff --git a/classsymtensor_1_1MultipoleBaseFromTuple.html b/classsymtensor_1_1MultipoleBaseFromTuple.html new file mode 100644 index 0000000..82816d3 --- /dev/null +++ b/classsymtensor_1_1MultipoleBaseFromTuple.html @@ -0,0 +1,274 @@ + + + + + symtensor::MultipoleBaseFromTuple class | symtensor + + + + + + + + + + + + + +
      +
      +
      +
      +
      +

      + +
      template<typename Implementation, typename Tuple>
      + symtensor::MultipoleBaseFromTuple class +

      +

      Helper class for defining a multipole based on an std::tuple of tensors.

      + + + + + + + + + + + + + + +
      Template parameters
      ImplementationCRTP subclass
      Tuplethe std::tuple of tensors. This is typically produced using TensorSequence
      + +
      +

      Base classes

      +
      +
      +
      template<class Implementation, typename ... Tensors>
      + class MultipoleBase<Implementation, Tuple> +
      +
      Multipole base-type for use with CRTP implementations.
      +
      +
      +
      +

      Member access

      +
      +
      + auto tensor() const -> const auto& constexpr +
      +
      Tensor access by rank.
      +
      + auto tensor() -> auto& constexpr +
      +
      Tensor access by rank.
      +
      +
      +
      +

      Multipole-scalar operations

      +
      +
      + auto operator+=(const T& scalar) -> Implementation& constexpr +
      +
      Element-wise addition of a scalar.
      +
      + auto operator-=(const T& scalar) -> Implementation& constexpr +
      +
      Element-wise subtraction of a scalar.
      +
      + auto operator*=(const T& scalar) -> Implementation& constexpr +
      +
      Element-wise multiplication by a scalar.
      +
      + auto operator/=(const T& scalar) -> Implementation& constexpr +
      +
      Element-wise division by a scalar.
      +
      + auto operator+(const T& scalar) const -> Implementation constexpr +
      +
      Element-wise addition of a scalar.
      +
      + auto operator-(const T& scalar) const -> Implementation constexpr +
      +
      Element-wise subtraction of a scalar.
      +
      + auto operator*(const T& scalar) const -> Implementation constexpr +
      +
      Element-wise multiplication by a scalar.
      +
      + auto operator/(const T& scalar) const -> Implementation constexpr +
      +
      Element-wise division by a scalar.
      +
      +
      +
      +

      Multipole-multipole operations

      +
      +
      + auto operator+=(const Implementation& other) -> Implementation& constexpr +
      +
      Element-wise addition with another multipole.
      +
      + auto operator-=(const Implementation& other) -> Implementation& constexpr +
      +
      Element-wise subtraction by another multipole.
      +
      + auto operator*=(const Implementation& other) -> Implementation& constexpr +
      +
      Element-wise multiplication by another multipole.
      +
      + auto operator/=(const Implementation& other) -> Implementation& constexpr +
      +
      Element-wise division by another multipole.
      +
      + auto operator+(const Implementation& other) const -> Implementation constexpr +
      +
      Element-wise addition with another multipole.
      +
      + auto operator-(const Implementation& other) const -> Implementation constexpr +
      +
      Element-wise subtraction by another multipole.
      +
      + auto operator*(const Implementation& other) const -> Implementation constexpr +
      +
      Element-wise multiplication by another multipole.
      +
      + auto operator/(const Implementation& other) const -> Implementation constexpr +
      +
      Element-wise division by another multipole.
      +
      +
      +
      +

      Comparison operators

      +
      +
      + auto operator==(const Self& other) const -> bool defaulted constexpr +
      +
      Comparison with another multipole.
      +
      +
      +
      +

      std::tuple compatibility

      +
      +
      + auto underlying_tuple() const -> const TensorTuple& constexpr +
      +
      direct access to the tuple of tensors which comprises the multipole
      +
      + auto get() & -> auto& constexpr +
      +
      element access for use with structured bindings
      +
      + auto get() const & -> const auto& constexpr +
      +
      element access for use with structured bindings
      +
      + auto get() && -> auto&& constexpr +
      +
      element access for use with structured bindings
      +
      +
      +
      +
      +
      +
      + + + +
      + + diff --git a/classsymtensor_1_1SymmetricTensor.html b/classsymtensor_1_1SymmetricTensor.html index afe34ee..4c053b4 100644 --- a/classsymtensor_1_1SymmetricTensor.html +++ b/classsymtensor_1_1SymmetricTensor.html @@ -31,9 +31,10 @@
      1. Pages
      2. +
      3. Namespaces
      4. Classes
      -
        +
        1. Files
        2. @@ -81,7 +82,7 @@

          I - index type + index type, defaults to the appropriate symtensor::Index diff --git a/classsymtensor_1_1SymmetricTensorBase.html b/classsymtensor_1_1SymmetricTensorBase.html index c0d6aff..99322e8 100644 --- a/classsymtensor_1_1SymmetricTensorBase.html +++ b/classsymtensor_1_1SymmetricTensorBase.html @@ -31,9 +31,10 @@
          1. Pages
          2. +
          3. Namespaces
          4. Classes
          -
            +
            1. Files
            2. @@ -85,7 +86,7 @@

              I - index type + index type, defaults to the appropriate Index diff --git a/dir_ac8328523b41d8ce239fc77edbe15305.html b/dir_ac8328523b41d8ce239fc77edbe15305.html index 36caba5..5309eeb 100644 --- a/dir_ac8328523b41d8ce239fc77edbe15305.html +++ b/dir_ac8328523b41d8ce239fc77edbe15305.html @@ -31,9 +31,10 @@
              1. Pages
              2. +
              3. Namespaces
              4. Classes
              -
                +
                1. Files
                2. @@ -74,8 +75,12 @@

                  Contents

                  Files

                  +
                  file Index.h
                  +
                  Index types and convenience functions for working with indices.
                  file Multipole.h
                  Provides the generic multipole type alongside typedefs for common uses.
                  +
                  file MultipoleBase.h
                  +
                  Provides the base multipole template.
                  file SymmetricTensor.h
                  Provides the generic symmetric tensor type alongside typedefs for common uses.
                  file SymmetricTensorBase.h
                  diff --git a/files.html b/files.html index 596c6db..299089e 100644 --- a/files.html +++ b/files.html @@ -31,9 +31,10 @@
                  1. Pages
                  2. +
                  3. Namespaces
                  4. Classes
                  -
                    +
                    1. Files
                    2. @@ -61,7 +62,9 @@

                      Files

                    3. dir symtensor namespace symtensor @@ -85,6 +87,11 @@

                      Classes

                      class MultipoleBase
                      Multipole base-type for use with CRTP implementations.
                      +
                      +
                      template<typename Implementation, typename Tuple>
                      + class MultipoleBaseFromTuple +
                      +
                      Helper class for defining a multipole based on an std::tuple of tensors.
                      template<typename S, std::size_t D, std::size_t R, typename I = Index<D>>
                      class SymmetricTensor @@ -100,6 +107,32 @@

                      Classes

                      Typedefs

                      +
                      +
                      template<std::size_t D>
                      + using Index = typename IndexTypeForDimension<D>::type +
                      +
                      Enum-class index type for a given dimension.
                      +
                      + using Quadrupole2f = Multipole2f<2> +
                      +
                      2d quadrupole with floating point elements
                      +
                      + using Quadrupole3f = Multipole3f<2> +
                      +
                      3d quadrupole with floating point elements
                      +
                      + using Octupole2f = Multipole2f<3> +
                      +
                      2d octupole with floating point elements
                      +
                      + using Octupole3f = Multipole3f<3> +
                      +
                      3d octupole with floating point elements
                      +
                      +
                      template<std::size_t Order, typename ... PrefixTensors>
                      + using TensorSequence = typename TensorSequenceHelper<Order, PrefixTensors...>::type +
                      +
                      Produces an std::tuple of tensors based on a "prefix" and a desired order.
                      template<class ST, std::size_t R>
                      using ReplaceRank = typename ReplaceRankHelper<R, ST>::type @@ -112,8 +145,110 @@

                      Typedefs

                      Given a symmetric tensor type, finds the symmetric tensor of the next higher rank.
                      +
                      +

                      Functions

                      +
                      +
                      + auto numValuesInTensor(std::size_t D, + std::size_t R) -> std::size_t constexpr +
                      +
                      Determines the number of indices in a square tensor of rank R and size D.
                      +
                      + auto numUniqueValuesInSymmetricTensor(std::size_t D, + std::size_t R) -> std::size_t constexpr +
                      +
                      Determines the number of unique values in a symmetric tensor of rank R and size D.
                      +
                      +
                      template<std::size_t R, typename I>
                      + auto dimensionalIndices(const std::size_t& flatIndex, + std::size_t D) -> std::array<I, R> constexpr +
                      +
                      converts a flat index to an equivalent multi-dimensional index.
                      +
                      +
                      template<std::size_t R, typename I>
                      + auto flatIndex(std::array<I, R> dimensionalIndices, + std::size_t D, + std::size_t lowestIndex = 0) -> std::size_t constexpr +
                      +
                      Converts a multi-dimensional index in a symmetric tensor into a flat index.
                      +
                      +

                      Typedef documentation

                      +
                      +

                      + +
                      + template<std::size_t D> +
                      + using symtensor::Index = typename IndexTypeForDimension<D>::type +

                      +

                      Enum-class index type for a given dimension.

                      +

                      For 2d, this contains elements X, Y, for 3d X, Y, Z, for 4d W, X, Y, Z.

                      +
                      +
                      +

                      + using symtensor::Quadrupole2f = Multipole2f<2> + +

                      +

                      2d quadrupole with floating point elements

                      +
                      +
                      +

                      + using symtensor::Quadrupole3f = Multipole3f<2> + +

                      +

                      3d quadrupole with floating point elements

                      +
                      +
                      +

                      + using symtensor::Octupole2f = Multipole2f<3> + +

                      +

                      2d octupole with floating point elements

                      +
                      +
                      +

                      + using symtensor::Octupole3f = Multipole3f<3> + +

                      +

                      3d octupole with floating point elements

                      +
                      +
                      +

                      + +
                      + template<std::size_t Order, typename ... PrefixTensors> +
                      + using symtensor::TensorSequence = typename TensorSequenceHelper<Order, PrefixTensors...>::type +

                      +

                      Produces an std::tuple of tensors based on a "prefix" and a desired order.

                      + + + + + + + + + + + + + + +
                      Template parameters
                      Orderrank of the highest tensor of the sequence, which appears last in the std::tuple
                      PrefixTensorsat least one low-order tensor which will be used to define higher order tensors. The last tensor of PrefixTensors is used to produce higher order tensors through repeated use of NextHigherRank.
                      +

                      The prefix determines the types of the tensors which make up the sequence. For example, the following TensorSequence<3, SymmetricTensor3f<1>> produces the type:

                      std::tuple<
                      + SymmetricTensor3f<1>,
                      + SymmetricTensor3f<2>,
                      + SymmetricTensor3f<3>
                      +>

                      The prefix may also contain types which are not symmetric tensors, so long as the final type of the prefix implements SymmetricTensorBase. For example, TensorSequence<3, float, glm::vec3, SymmetricTensor3f<2>> uses a float scalar component and a vector from GLM, this produces the type:

                      std::tuple<
                      + float,
                      + glm::vec3,
                      + SymmetricTensor3f<2>,
                      + SymmetricTensor3f<3>
                      +>
                      +

                      @@ -163,6 +298,193 @@

                      All properties of the symmetric tensor ST are preserved aside from the rank. The type of NextHigherRank<SymmetricTensor3f<3>> is equivalent to SymmetricTensor3f<4>.

                      +
                      +

                      Function documentation

                      +
                      +

                      + std::size_t symtensor::numValuesInTensor(std::size_t D, + std::size_t R) constexpr + +

                      +

                      Determines the number of indices in a square tensor of rank R and size D.

                      + + + + + + + + + + + + + + + + + + + + +
                      Parameters
                      Dsize of the tensor along all axes
                      Rrank of the tensor
                      Returnsthe number of values the the tensor
                      +

                      Equivalent to + +$ D^R $ + + + + + + + + + +.

                      +
                      +
                      +

                      + std::size_t symtensor::numUniqueValuesInSymmetricTensor(std::size_t D, + std::size_t R) constexpr + +

                      +

                      Determines the number of unique values in a symmetric tensor of rank R and size D.

                      + + + + + + + + + + + + + + + + + + + + +
                      Parameters
                      Dsize of the symmetric tensor along all axes
                      Rrank of the symmetric tensor
                      Returnsthe number of unique values in the symmetric tensor (indices xxy, xyx, and yxx are not counted separately).
                      +

                      Equivalent to Pascal's triangle evaluated at D-1, R.

                      +
                      +
                      +

                      + +
                      + template<std::size_t R, typename I> +
                      + std::array<I, R> symtensor::dimensionalIndices(const std::size_t& flatIndex, + std::size_t D) constexpr +

                      +

                      converts a flat index to an equivalent multi-dimensional index.

                      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                      Template parameters
                      RRank of the tensor
                      IIndex type
                      Parameters
                      flatIndex1-dimensional index, in the range [0, N)
                      where N can be found using numUniqueValuesInSymmetricTensor
                      Dsize of the tensor
                      Returnsstd::array of indices, with type I and size R
                      +

                      The index is in "canonical" form. For a + +$ 3 \times 3 \times 3 $ + + + + + + + + + + + + + symmetric tensor, this means the following mapping:

                      0 --> X, X, X
                      1 --> X, X, Y
                      2 --> X, X, Z
                      3 --> X, Y, Y
                      4 --> X, Y, Z
                      5 --> X, Z, Z
                      6 --> Y, Y, Y
                      7 --> Y, Y, Z
                      8 --> Y, Z, Z
                      9 --> Z, Z, Z
                      +
                      +
                      +

                      + +
                      + template<std::size_t R, typename I> +
                      + std::size_t symtensor::flatIndex(std::array<I, R> dimensionalIndices, + std::size_t D, + std::size_t lowestIndex = 0) constexpr +

                      +

                      Converts a multi-dimensional index in a symmetric tensor into a flat index.

                      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                      Template parameters
                      RRank of the tensor
                      IIndex type
                      Parameters
                      dimensionalIndicesarray of R Index types which specifies a value in the tensor
                      Dsize of the tensor
                      lowestIndex(implementation detail)
                      Returnsthe corresponding index in a flat array with no redundant values
                      +

                      First puts the index in "canonical" form, where indices are sorted as follows:

                      {X, X, Y} or {X, Y, X} or {Y, X, X} --> {X, X, Y}

                      Next, converts the indices to a flat index using the reverse process of dimensionalIndices()

                      X, X, X --> 0
                      X, X, Y --> 1
                      X, X, Z --> 2
                      X, Y, Y --> 3
                      X, Y, Z --> 4
                      X, Z, Z --> 5
                      Y, Y, Y --> 6
                      Y, Y, Z --> 7
                      Y, Z, Z --> 8
                      Z, Z, Z --> 9
                      +
                      +

          diff --git a/pages.html b/pages.html index a1410c2..a5e4f8a 100644 --- a/pages.html +++ b/pages.html @@ -31,9 +31,10 @@
          1. Pages
          2. +
          3. Namespaces
          4. Classes
          -
            +
            1. Files
            2. diff --git a/searchdata-v2.js b/searchdata-v2.js index 8011a7e..d6f3012 100644 --- a/searchdata-v2.js +++ b/searchdata-v2.js @@ -1,2 +1,2 @@ /* Generated by https://mcss.mosra.cz/documentation/doxygen/. Do not edit. */ -Search.load('O+!-x00000Hvj+tq6z>21Q`GTTnYdH0ssL30{{R4DFgrj0s#O30strq0Du4iWe@-W00DCv00001VITki00Ckq00001Wh?*y00C?=00001Z#Vz|00D4500001X+!`300DGL00001Y)}9I00DJY000622LJ^C00Ajt000631^@&AC};qH00DAt00001Z+HLz00DD;00001ZiD~;00Cu+000312><{ADV6{L0RadAD4GC(0RRyI00Ake000335CA00DFE0RR92Ve|n200Cn90RR92asUDV00D0X0ssI3a|{9i00C|i0ssI3Wf%eg00DF!0ssI3V(^cDV72N0RbccD4GI*00DEL0ssI3WvBuG0st`pF8}}mDYOCr0s$}pE&wRH0)PMkUBChW0suV#O#lD^DbNA{0s%Y#OaLg>0)PSlMF3F%00AlH0ssO6L;z3#Jt*7)0PF&Q0sub%PXGV`DF6ci0s%e%P5>wd1AqbmM*vd*00Ai$0{{X7MgUR(JtzzV02~8=0RTY&00Aj50{{U5KmaH-1AqYlNdN!=DMAAP0Rl(>Jt#T@07e6V0RTe)00Ajj0{{U5LI5aS1AqYlO8@`?DQW`%0Rl<@Jt$%W0B!?-0RUA100Ak00{{U5Q~)T11AqVlJ&FSW00vttEh;ZP$^roL0stZd089e_bOQjA0{{R4a+m`E00D2Z0{{R4bhrZm00CjX0{{R4a>N4w00Cvn0{{R5Zg8#w0MG*f0RSfe00AlB0{{U5CIBep1AqVlbLs;C00D3E0{{R4a`*!P00CwG0{{U4DF6TgDGCGt0RbogC=LXG00C|k1ONa5ZyW>w00C(t1ONa5b0`D=00DC@1ONa5Wi$i;00DA31ONa5a6kkA00DSL1ONa5WlRJB00DVY1ONa5a##ca00CiM1ONa5Y-9ug00C@j1ONa5b#Md#0RSri00Aj{1ONd6DgY>e1b_ema)tx|00Cu=1ONa5ca#JG00D2B1ONa5aG(SL00C~M1ONa5VXOoI00C*T1ONa5bGQTm00Cvb1ONa5bi@Pz00DB!1ONa5VbBBs0RSxk00Al71ONd6EC49r1b_emY~}<200Cj{1ONa5ZuA5I00D3M1ONa5X8;8N00ChJ1poj6X$%Db0su7tGXMYqDHsI+0s%AtG5{zZ1%LnnbR-1;0suJxHvj+uDKrHD0s%MxHUKC(1%LnnbU+0F00Ci21poj6Y)}ON0RTGy00Ajn1pom7IshnO1%LnnWo88c00Coe1poj6VRQum00DA(1pojFb7^mSZewI&W^_~n0FVLz)&l?p1ORpf0M-Nm5(NM*1prnB0DuJm00BCN1pom7RscG%1%LnnWwr$X00DEp1poj6VZ;Rh0RbEUV#);o00DB)1poj6Z`cI@00DE}1poj6ZsY|300Cv{1poj6bnpcL00Cq61poj6Y5WBM00D9W1^@s7bO;6j00CtV1^@s7Z4?Fo00C_p1^@s7c_0P=0RUP600C<(1^@s7ZZHM_00Ch(1^@s7ay$kA00Ct}1^@s7V@L)700Ci61^@s7Y*YpS00D4X1^@s7WncyX0RUS700C=k1^@s7Zg2(w00Cik1^@s7a(o5=00DA>1^@s7Wrzj<00C%@1^@s7XOsp200C*51^@s7XrKlF00DHS1^@s7c&r8h00CvP1^@sAZF6#N(g6S_1^{LT0JsJK00BC_1^@v782|tQXx0V*00A!A1^@s7W#9$?00DF61^@s7VeAF~0RUJ400C(D1^@s8VlMIq0Q?3300D9W2LJ#8Zwv00D9~2LJ#8bUX(D00Ct}2LJ&8R{#J3Xif(J00Ayi2LJ#8a##ld00D1a2LJ#8b7Thq00C}l2LJ#8WpD=o00M1vNCyCR2LJ#8ZF~m+00DW12LJ&8UH||AXp#p200AzR2LJ#8Wt;~900C^G2LJ#8Z>R?V00D5W2LJ#8X|x9b00DHm2LJ#8Y`_Nq00DKz2LJ#9b8U99RL6Ub6yAl00DAh2mk;9Z)gYr00DDu2mk;9ZgdC$00Cus2mk;9bbtr|00ML%SO@@y2mk;9V~hv@00C*12mk;9a-0YN00DHO2mk;9WvB=M00MMv2nYbK2mk;9ZL|mg00DWv2mk{D7ytkO0suNFfB}FC0Du4iWy%Nu00DE_2mk;9Vc-Y=0RUM50RtNVVskF$2mtH|0G0;;00Cw22mk;9Yyb%W00D0X2><{Aa103m00C(d2><{AbQlQ$00C?s2><{AbtDM@00L!liU0t51pos82>?9+O#lD^DLM%N0|5vCJOE4pC_)K<0{{^KMF3F%00Ajf2>=5E5CB8~PyjtBNC^O334j9t3jjX=PXGV`DRKz_0|5#EJ^)StD0&Hi0{{~MM*vd*00AkC2>=5E5&%X3QUE=2C3;;j?D6k2D0ss{NNdN!=DZmK;0s<5ONB})3wg~{n34j6s4*){|00Al52>=2C4gf*`DBuZz0st2PO8@`?DewsZ0s{9h0Fna$00D9e3IG5BZzKu;00DF=3IG5BVK52+00D9~3IG5BWjqQ100MAsLJ9z`0ssI4b!Bh_0I~)E01R_&bZ=>TZewI&W^%*`04fOpFbM!i3ILD-00aa8QVIap1OO5R04@apRs{fN1^|Bn0Ji}Ex&Z(H0ssU8051XnGXel)0sv%0}0|55}067EzJp=%M1OS5s0F(p($pir11ON;L07nG?oCN^d1pwUz03!wfCk6mo1^`_K0E`9zj|Kq01^~ha0RIL60|x*}2LMe60F4I#kp}?02LQka01yZO6bJx62mnI}0B{HZa|i&Q2mqo80MQ5l)Cd3y2>=cW08j}4R0#l<2>_Z20Ne=x;0XXC3IHYw0Bs5YaS8yq3IMzc00RpE2MYjB3jk6J0GtZ|pbG%%3jpp506h!i20NM-y-V6Zm3;+-f06h%=gbe_<4FK&801gfSK@I?74gjgBsi~={si>)`si~={si~={si~={si{bq5J*T6si>)`si>)_si>)`si~={si~={si~=`si~=`si~={si~={si~={si~={si~={si~={si~={NSK%qcz7Uym>2*g0y;WPb!>ELaBpm7LSb`dC@BCVVPP{hV>o3wV=-o7H#RgfH8VIhVq`EjI5sgbGGRA3H2?rc7yu*?Iyy~tY;hG-fbjVqs%qHDzI9VlXygIWadgGBr44GGPJ$Mh*r5CI}#7Z*FsR0Ae>XW??WlWoBb#HDfX}H)LWrWHMo8GC4P5F)}kVHUt1h1{eS&0y;W$Wo~nCawsVPBVjmVFk)pjGBY-1WHMtkIbt+1IXN;gV=y-}FgRpnH8KVOMi>Aj3OYJ(aAk5~bZ>GiJt$*uZgX@XR3<3^BVlG?VlifBW;A1EG&C|WV_`TqGh;YmIbk$oVPiKlH)IF^MhF-HBnmn@Z*XODVRUbDEj=h>Z*FsRAXFwP03%^$F)%eWH8nLbV`F1BGBRT{G+{D0GGSpjV`MR8H8n8`07eKH03-@JI&W}ga$$6DawGiC}VGKb95k7CMh6eZ*FsR03%^yGi5hnVKrtlVq`NiFga#sH#ImoIWageH#cH1G+{Fk07ecN03;API&W}ga$$6DaxExhZ*FsRAXFwPAY*TCb94YBVPrBmVq|4vGc;v0V_`I8V=_53VPR!AWi~lEF=AmeW)c8K4j2F=5IQ<GhC}VGKb95k7CMh6eZ*FsR03%^HGC5%}HfCcqH)dmDGch+|H8o^qVmC85Fl1(8WH4qF07ecN03;API&W}ga$$6DaxW-jZ*FsRAXFwPAY*TCb94YBVP!NkWHMnjV`evFG-YIFF*G?fHZ^85WH>iwIW}TuVio{K4jTX)LSb`d077ANWiDuRZEP9<054N{ZEaf0BWdLJrVRLhHd2MuMZgX#PUol@XO?7N^X>f0BWiDuRZEP9<06IETd2MZFbaH89RAp{+Z*l-*Y+-YAb9rraWo~nCa$hlDF;jVMZDn+FX=7AnZgX#PE@*UZY*Tq{ZDn+FX=5N%Wo~nCa&rJ}WM5xsZ*65?a&>NQWpZD4Z*ps2b9rraWo~nCa$j?KZFFUBb8m8AWN%|%b9rrTWpr|BV_$S-ZgX#Pb1rCfZERKmDgrt>Q+aJ|Wpr|BV^n2sb8m7&VRL0DDF7p3WinwjVlXr?GdDG5GGaDiWnp1CFlIJmWnwjDH!x;29so>M04fSPI#YRVZDn+FX=7AnZgX#PLSb`dC}DMUZy+u%E-3&bVPrHhHa0RgH#j(CH#jynGGRA2HD)@rgDF7p3G&VLlH8(jiWM*VGV>mZ5F*al~V=yu|GB7!2Fg7+aA^=QQ04f4HI!|t8b0{eQBVl1=V=!blGG;b1W??ZiI5%TqI5aUhHDNMgGh<~kV=*KEOjZCY0y;WcWpZzGC@BCVVK!kfFf=eSVl^{2I5s&oVKzB1I5s#jFk&(@HD)V>QMkxRzVK-zmH!x#jW->NoV>DqkGGSt6F)}$eGcz@2IAdioV<-Sj0agGi4>~$SVRCe3b7^62P;Yl-awubOZgX@XR%K&!Z*nFn03%^!IWaIfVKO&2H83+_G-PCEF*!40I5sjhF*r0gVL4+e089;504fhUIz(wD(sF*qZ*FsRAX8&uY+-UHDF7p3F*7w}IW{&qV=y&kH)As~WHvHmF*Pz|GiGHlWnyMDJ^)M&RsbpwIy!G~WpZJ3Z*nRiuGBY(XFk?UfObu25Di1n3Z*XODVRUbDFFhz@Z*FsRAX8&uY+-UHDF7p3I5uTsW-w$pFgG+aVPZ68VlZViW@I#DHZ(P6F=JseLI6w+Rsbp$Iy!G~WpZJ3Z*nUrV{dMAbRbh>VQgV?CMh6eZ*FsR03%^zV>vP~HDNGhH#jz9GdN)~F*Ig2GGt^jF=jVnVl_8J08A5B04fzaI&W}ga$$6DaxExhZ*FsRAX8&uY+-UHDIjBSZgX@1BVjQ#W;9|sGc{y3WMpA5GdE%}IXO2mHeoepWi@1CH#tTCOcPcBDiu09Z*XODVRUbDDkx)bZgX@XQ)6LlVR9xZAY*TCb94YBVKQc8V`MlnHD+WsHZwV4VKX;3WHVziG+||AIWcBqW=H@`6IK8!6*@X^aAk5~bZ>GmC}VGKb95k6V_|GzawaJtV{dMAbO0k^GcqzWWoBh%I5IFXH#1{4V>dE6Fkv}0IWRCXGBh+bN&rj~Rsbp&Iy!G~WpZJ3Z*nU=C}VGKb95j{ZE$R5ZDnqBVRUJ4ZYC)JBVl4;H928pFk)t5WH~S}G-hFCI5#;oV>UT7W-(=BVmV9zOchoDDi=CBZ*XODVRUbDEj=h>Z*FsRAW3a-Y-Md_ZggREX>V>ODF7p3W@KSEGB7wWGdDLlG-WYlVmW4JWMN`3VPrC5V=^!>P5?|5Rsbp;Iy!G~WpZJ3Z*nUrV{dMAbRbD>aBO95Wo~p~bZKvHCMh6eZ*FsR03%^zI5ae2Gh}6BWHmK0Ff}nZW@TbCV`VjAH8(XdWo0%{08ATJ04g0iI&W}ga$$6DaxExhZ*FsRAW3a-Y-Md_ZggREX>V>ODIjBSZgX@1BVjl)VL4+lF*7%1WMnutGi5b6F*jj0VKOy2VlZZ6W;Id(OdD1JDib<7Z*XODVRUbDJv}I6Z*FsRAX8;*W+o{hV{dMAbO0k^V>LK3Vm4wiW;i)8F=S?DH8wb9Wo9{LI5II~W??irQ~*p78~`CgVRK~wLSb`dE@*UZY#IOnFLQZqbY*UHZ*neZ0CRb5bY*UHZ*pHaXf9}UZEP9<054N{ZEaELaBpm7a{z5*Utef%ZDn6_b#88Da$k3Ea%*36d2MuMZgX#PUvqhFbY*UHZ*pH`Z)0C=b!>ELaBpm7b1rCfZERcs7dkppWpHd^V`WldZfgJ|VKz8rGc;miIbt_8WHvBkG-EL_VKq53F)%bXWMyJAFU80G&o^0HDzI9WjQluF*P+gH8?OZV`4XRd2MuMZgX#P0B&JzWpi+0V`X!BZFFUBb8m7kXmo9Cb9rraWo~nCasXs$a$jL%I5RRhH8L||G%;j2V`VZkIc8%wH)UjEWid4~Ff}e{bZu-J001vdb!>ELaBpm7E@%Kvb!>ELaBpm7UpQzkXmo9C0v-V(0xJP90W|?T0YC#s14;!>1yTW609*iM0B3MvXJu|-ZDn(CVPj=ya&L8TV{Bn_b8~cZbz^jOZfS3Bba`-PWMyV#X>w+1Y-MJ3ZewI+W@&C^Wo~tCWo~tCAa-GFc42Y='); +Search.load('O+!-x00000Qvd(}pb!86^d00002VlIXN0FVFx00DBA00001Z=e7G00DER00001Zma+R00CvP00001bhrQj00CpZ00001X~X~k00DB!00001bkG0*00Cvz00031bN~PWXyO0>00A!M00001a_j&A00D3E00001bNB!N00D0P00001Wds2L00M1v+yDRy0RR92Z4dzf00DU#0RRC2bpQYXXeI#w00Ay40RR92crXC~00Ct-0RR92WIO=?00C}70RR94ZF6a4001BX07wA<0ssU61^@s7DO>>n0s#X61pp{w0e}DjWoQ8a00DDy0RR92VR!)m00Clt0RR92WrP6$00C@@0RR92Z;$~100D580RR92X`BH700DHO0RR92Y^VVM00DKb0RRF33IGTI00Akw0RRF42>=HGD8K=L00DBw0RR92Z_oh%00DE>0RR92ZrlL?00Cv<0RRF33;-Me00AlP0RRF43jiAcDD(k<0ss^MBme*bDFgxl0s<2NBLF=p`T+n60)PSl4geki00Ai;0ssO54FDYgC?o=a0ss~OCIA2dDKr8A0s<8PB>+7rDgppH0)PSl5C9+m00AjZ0ssO54*(wkC{zM~0st5QC;$KfDP#fw0sL0s0{{R4WsCy=00nJyZ*^z10RZR$00093Yy$w20{{R4I+z0h0RVRZ00CvR0{{R4Y`6me00D5m0{{R4b;JVz00DH$0{{R4ZO{V%00D2-0{{R4a@+#|0RlAuI%ci|fZ_uH00Cv_0{{R4bMylM00Ck80{{U5H~?Y*1ONa5Wd;NQ00C?c1ONa5ZxjRo00D3s1ONa5X&?ju00DF+1ONa5Y%Bx-00DI}1ONg6JODlb00AjJ1ONg7I{-ZZC`1H+00Cu61ONa5b5sNX00CiI1ONa5VqgRS00DAl1ONa5Z)^kr00DDy1ONa5Zg>O$00Cuw1ONa5bc6%|00Co)1ONa5X^;c}00DBA1ONa5beseL00Cv91ONa5ZKwnQ00C{T1ONa5d9(xo0RTV%00Ak$1ONd6KL9Ai1b_emdCCL;00DH;1ONa5Y1jk+00DH~1ONa5ZsY_200Cv{1ONa5Wbgz40RTb(00Ald1ONd6K>#QK1%Lnna|Q(f00CtV1pop7P5?{*00Ai)1pop8O#n*(C?ExZ00CVl1pop7S^#PQ00AjB1pop8SpaDOC_Dv#0svwFZU6uQDNF?b0s>(GZ2&zeLInU)1%LtoTmWnU00Ajx1pop8TL5bSC~O6Q0sv$HZ~y=SDSQP00s>c_1%LqnUH||ADV7BQ0RdeAD4GR;0RUzI00Ake1pom8WdJ=WpalS|1%LqnU;qFCDZT{&0RdkCD8dDR0RU(K00Ak`1pom8X8=7Y$OQn@1%LqnasU7UDdq(L0ReFUDCz}(00BMl1pojBTPrOpFFh~?09XY8hy?($1pwLw0Qdy}00DCT1poj6Zx{vu00DF!1^@s7VI&3s00D9;1^@s7WiSQ+00M4s6a@e_1^@v7L;wH*DMkhW0Rck*C`tx^00DDQ1^@s7Z&(HZ00DAd1^@s7Wn=~b0RTn-00Aj*1^@v8MF1#t27mwoZh8g)00D1;1^@s7X@~{@00DE31^@s7bCd=E00Cv11^@s7a-aqP00D5O1^@s7c&r8h00CvP1^@s7dAJ4u00DBo1^@s7VZ;Ui00C^u1^@s7Y|sV(00DK@1^@v7NB{rDMAMT0Rc$>C`Jc>00C@F2LJ#8VN?eI00C}V2LJ#8Z(s)i00C!a2LJ#8VQdEg00C)o2LJ*9QUFi@00Aj}2LJ*AQ2D1--q00DH02LJ*9Rsd8000AkQ2LJ*ARRB`}D4+*`00DHS2LJ#8VXy}P00C^a2LJ&8SO5S4DZ&Q;0RdM4D8>hX00Cvp2LJ#8W7G!#00Cjz2LJ#8a^MF5019(yZ+dQHWMO7>xB1OPk+0BQyR+y($V2LN~n0F(y+yaxd02LJ#8I_w7k0ReLWIu;0k00Ctj2mk;9b0i1=00Cht2mk>AIRIiX2mk;9ayAG600D142mk;9b3_OL00C}F2mk;9Wl#tJ00DGX2mk;9V_XOT00C)Y2mk;9a%czu00DGv2mk;9WpoGt00C`!2mk;9ZGZ>>00DW12mk>9c>n+bc#;SJ00Cu|2mk;9WSj^900C~I2mk>9dH?_cX08YT0RVdd00CyW2mk;AGBdIW0K5nQ00Cvf2mk;9Y|ID%00D2(2mk;9aM%a{00DL02mk;9a^wgA00Cs`2mk;9Vekk500DLO2mk>9d;kCeW&#NS0RVjf00CwU2><{BGBXAV01ycP00Ctd2><{AY#<2$00D0%2><{Aa4ZP`00DI}2><{AbT|nB00Cn@2><~AegFUgWl9ME00Co82><{AZd3^X00CuM2><{Abzlhq00D7k2><{AWo!um00DDy2><{Aa(D><00D1)2><{AbA$;100C}_2><{AWsnH~0RVph00C>92><{AZlDPO00Cj92><{Aa;yme00CvP2><{AW4H+b00CjX2><{AY{Urw00D5y2><{AWzY!#0RVsi00C><2><{AZr}+300Cj<2><{Aa_k8J00DCH2><{AW%vmI00C(J2><{AX9NlW00C(V3IG5BXb=hj00DFs3IG5BcpM4<0RVyk00Ai|3IG8CfdD8h3V;9saxw}400D103IG5Bb3h6J00C}B3IG5BWlRbH00DGT3IG5BZdeKc00C)U3IG5Bb7Tqt00Cuc3IG5Bb#Mv*00C@v3IG5BVSEYz0RV&m00Ak83IG8Cg8(Ru3V;9sa*_%F00D2B3IG5BbD#NP%00DH$3IG5BWzY%$00C{*3IG5BZQKd~00DX83IG5BbLa{H00D093IG5BY4i#J00DFQ3IG5BWdI8R00DId3jhECYzzwk00ChV3jhECb{Go)00Ctl3jhECbtDS_00D6-3jhECX)p@_00C|`3jhEDc6EXZ06Yr-00C`63jhEDWpyG7089%20RV;o00Ajn3jhHDg#ajE3xEItb7l(w00Cug3jhECV{{7u00C)w3jhECWPl3*00C}>3jhECX^aa100C^03jhECVVDa500C~E3jhECZ=?$V00C*L3jhECbFd2l00C~c3jhECWxNXj00C{n3jhECX~+uz0RV^q00Ak~3jhHDhX5$p3xEItc-{*D00Cv@3jhECWb6w700D0D3jhECY4{5O00DIV3jhECVFU~S00C?Y3;+NMZF6aHZ*+2QWM()70E`F#s0aZ32mnM00G0^=)(HSo3jodw01ylS00BA{3;+WIHvowMiU2P00D2(3;+NDbJz?300C~^3;+NDW#kM100DIB3;+NEbRfbE0PqX|00Cq63;+NDX#foX00D9a4FCWEbPNpu00CtZ4FCWFbZv4B02mDb00C_t4FCZE0RR92J}wOa00DF|4FCWEAUF*G00AsM4FCWEX+#YG00BHo4FCWEbWjZd00C}R4FCWEWn2va00C`c4FCWEWoQim00C@n4FCZE0ssI3K6(uR00DG<4FCWEJcJDZ00Cu+4FCWEdXNnO00C*14FCWFWpi{50Gtf~00Cd34FCWEWvmSV00C^W4FCWEaJUTs00DKr4FCWEbi@q+00BD64FCWEI?xS(00Csy4FCWFd2}cZ0Nf1#0|Yey0{{g8E;=Y?2mk=C1At-yfZ_uH00Cv}4FCWEa|8|m00ChN4gdiFcmM$dH~?aEE)Wg?77hR^00001Wf~3u00C?&4gdfFZ!iu300D3|4gdfFX*>=900DGD4gdfFY)B3O00DJQ4gdlI2>=HGD09F8fN}`{00DAZ4gdfFZ)gqx00DDu4gdfFZgdU+00VVpa=r}!dJX{K2LJ>B3;u{dC>9TZ0{|ERW&kJv00Ai|4*&xK7XW1dCjdPt91j364}b#z5&&QTA^-pZDMk+f0|5~LUjQKhC{7Q60{|KTXaFhz00Ajr4*&xK831PhDF8hvR1W}X4}byyEC6x<00Aj}4*&uID*$l-D1;Ay00BLU4*&oLD=jK7JzKmE0Q?RBHV*)94*--805Amr00DBE4*&oGZ?q2p00DHm4*&oGVZaXn00DBw4*&oGWy}u%00VGtW6}=*6a@f22><~Bc>pdd0RR92c;*iP00Cw04*&oGWb_XJ00Lxg@B{$*4*&oHY;Dj60744@00MPo3J?Gy3IG5CVQp*&0Ky9Z00C(p5C8%KRRB`}C~2SvfcOgl00DF^5C8xHVLT8300C@55C8xVb8U2Qb!TaMZewI&W^r=j4FFUQ0Dukv*be|~0|1f(000mGY6bul5CA*}04NXulm`Gv5CHrL0M-crGXely0syB10OA4w8Up|w0{~+K0A~XLk^=yi0|3VZ0LlXZ2Lu2M1OP|`089h`i39+R1OUne0L}ye5Cs4f1prnB09pkAoCN@&1pwj&0Okb%Fa`iL1^|8r0D=Yp%mx6^1^^ld03HVbZ3h5x2LQka0K^9X69@no2modX0BQ&Tum}LO2mtj60Qm?2DG2~A2>@dW0A~pRjR^pe2>_xA0M`is>j?lF3IJ6K0ICWA=n4Sq3IH(+05uB$XbS*q3jmr60G$f}%?kj~3jhra01*rTR}27K3;>%90G|v1$_xO`3;-St03r4*(Gm02L4bTo3?Y5CEzW0Im=K_z(d65CBUN08bGBo)G||5di2B0PGO}{Sg2j5&$<60AvyXe-Z%35&-iO04EawTN40{69B&x0QD09C=>u*6acam0JanW85IB>6##h^0DTnz+Z6!c6#xJh05cW)`si~={si~={si~={si~={si~={si~={si~={si~={si~={si~={NSF{vND!&0si~=`si>)_si~={si~={si~={si>)`si>)`si~={si~={si~={si~={si~={si~={si{bqn3zZqczAetczAetsi~={si~={Ab^-R001vdb!>ELaBpm7LSb`dE@%Kvb!>ELaBpm7LSb`dUpQzkXmo9Cb97`nI&^h#Y-L|%Y-Md_Zgf0JEFe@q0CRM5bz^jMbYx#KUomubaBO8?UuA4%ZDnqBUo&4YF-c!AFkdh+R9`SLUoLb97{1F<&usb#QEDUte=+dSzcTUobILUobIWG%jd#ZEQ6FBmz1*O?7N^X>f0BWkO+dWhf~CBVl1PHDfqsIb$(qVK+83GBqELaBpm7LSb`dC{$%`b8m8UASNatE-o%903%^AF*0OhF*If{Vq#%qVl`!9Vq!2hVL353Gcq+eWHMm|07ec8044|^V{dMAbO2&EGG<{gH)UpHWi?|mGdE;nH)JwlWimN8Vlgr^Gd2eRMg}ziBmz1*bY*UHZ*nLp03%^IVlZN5H8L|cWn?mAG&y24F*!LhFk>(`GcY)0WHmAg07f+cBnmn@Z*XODVRUbDD?KPFWi&K0Fk@jjH#1{6VL4$mV_{=AGdE-l07eKk03-@JI&W}ga$$6DaxFb5V{dMAbRbkFDF7p3W-%}|G&MCfFk@q5HZn3}G&Er{I5J^jIAdfnWHmK04FE<6H2@?EIy!G~WpZJ3Z*nRGmJt$*uZgX@XR3<3^BVjWzGBz<{HZwReVKOu@Fk@pdF)}eTGB7q_HZe0{He(S0MhGpVq`F87XU^MH2@?KIy!G~WpZJ3Z*ngvV{dMAbRbkFDIjBSZgX@1BVlDUGh{MhHDhKsV>D%CW-&B5H8wS7Gh{e7W;r%uW?~rtMh-OqBo{h5Z*XODVRUbDD?KPV>ODF7p3VqrBoVPi02W?^JGFfcS`VP!ZsIW%K7IW%T5Wn*GF8vsTXH2@?RIy!G~WpZJ3Z*na?C}VGKb95j{ZE$R5ZDnqBVRUJ4ZYC)JBVlG_VK*``I50CeH#jt9F=S#nW@cnzVlZK3GGb#gFfbheMin&xBo{h5Z*XODVRUbDDm^G;Z*FsRAW3a-Y-Md_ZggREX>V>ODF7p3W?^GDHezHoH8MD3WMMI8Ff(H|IAUZtV=yx^V=`uB9{@%bH2@?RIy!G~WpZJ3Z*ng^C}VGKb95j{ZE$R5ZDnqBVRUJ4ZYC)JBVlG{H)b+2IAJtqWnp44GdE;8VmUKoWMgDuGc`0dHaQ^xMin&xBpo_BZ*XODVRUbDD=1@cZgX@XNo{a!Wo>0{bYXO9Z*C?jAY*TCb94YBVPiNnG+{GjWn*MDH8C(XF*jyqVl!i9HDNV3H85pmHX{H=8#MqV9XdL1aAk5~bZ>GkC}VGKb95j{ZE$R5ZDnqBVRUJ4ZYC)pV{dMAbO0k^I5J^5V=*x^H)UjGI5sn7H8?RhVK!khH92B1W@2VFB>+YnH2@?XIy!G~WpZJ3Z*nRqV{dMAbRbD>aBO95Wo~p~bZKvHCMh6eZ*FsR03%^CHa0LdVL4(jFflneWMMOAG-YBrWic^iHZU+aI5IXT07e@%03;ncI&W}ga$$6DaxW-jZ*FsRAW3a-Y-Md_ZggREX>V>ODIjBSZgX@1BVjTzHZwFhGBz_aW??irG%zzYF=IJ4GG%3BHfA?5F*GRvMjJH%BojJ1Z*XODVRUbDJv}I6Z*FsRAX8;*W+o{hV{dMAbO0k^V>LK3Vm4wiW;i)8F=S?DH8wb9Wo9{LI5II~W??irD*#3jH2@?CIy!Z3WMy(}d1-EEUvzbFY-K1ZAY*TCb94YBVKHJkH8C?~GcaU0VP-aEH#lQ3H)3QrGB`42Gc!3gGA#f`1~mXA1UforWppShASM7KVPZBiFgY+VGht?9VlZZ5IA%6uH(_ODWHDtmGiEt6WG?_l0yO|63OYJxWppShAY*TCb95jk03%^EV>mcwGB{yjFk)djW;bDFFk>}lW->K0Vq!QkVKX-|07eKe044<{0A@5ZI59OdWn?g9H!(G2GBY_aIbk?5G-EVnV`OGEGcy2212_O1LSb`d077ANWiDuRZEQCH054N{ZEaf0BWdLJrVRLhHd2MuMZgX#PUol@XO?7N^X>f0BWiDuRZEQCH06IETd2MZFbaH89RAp{+Z*l-*Y+-YAb9rraWo~nCa$hlDF;jVMZDn+FX=7AnZgX#PE@*UZY*Tq{ZDn+FX=5N%Wo~nCa&rJ}WM5xsZ*65?a&>NQWpZD4Z*ps2b9rraWo~nCa$j?KZFFUBb8m8AWN%|%b9rrTWpr|BV_$S-ZgX#Pb1rCfZESM@Dgrt>Q+aJ|Wpr|BV^n2sb8m7&VRL0DDF7p3WinwjVlXr?GdDG5GGaDiWnp1CFlIJmWnwjDH!x;2I{-{`04fSPI#YRVZDn+FX=7AnZgX#PLSb`dC}DMUZy+u%E-3&bVPrHhHa0RgH#j(CH#jynGGRA2HD)@rgDF7p3G&VLlH8(jiWM*VGV>mZ5F*al~V=yu|GB7!2Fg7+aKLAW~04f4HI!|t8b0{eQBVl1=V=!blGG;b1W??ZiI5%TqI5aUhHDNMgGh<~kV=+MhOmhG#0y;WcWpZzGC@BCVVK!kfFf=eSVl^{2I5s&oVKzB1I5s#jFk&(@HD)Iyz2uY;0k2c|~||a%FRKX>V>QMkxRzVK-zmH!x#jW->NoV>DqkGGSt6F)}$eGcz@2IAdioV?_W=0doK<4>~$SVRCe3b7^62P;Yl-awubOZgX@XR%K&!Z*nFn03%^!IWaIfVKO&2H83+_G-PCEF*!40I5sjhF*r0gVL4+*089;Y04fhUIz(wD(sF*q08DcLDhN6{baG*1Whf~iV{dMAbO0k^WMgJwH)A(8Ff=tVG-YNmF*9Q@Fgas4W-(?sHZx*5R{%@~a{ww2Iy!G~WpZJ3Z*nU=C}VGKb95k6V_|GzawaJNBVjZ&H#KH8G%{f}WimA~G&ne9HZwUhVKiYjH(@zqG&orRObv4YDi1n3Z*XODVRUbDEj=h>Z*FsRAX8&uY+-UHDF7p3F*7w}IW{&qV=y&kH)As~WHvHmF*Pz|GiGHlWnyMDTL4TAa{ww2Iy!G~WpZJ3Z*nRiuGBY(XFk@W+Obv4YDi1n3Z*XODVRUbDFFhz@Z*FsRAX8&uY+-UHDF7p3I5uTsW-w$pFgG+aVPZ68VlZViW@I#DHZ(P6F=JseUjR%Ea{ww8Iy!G~WpZJ3Z*nUrV{dMAbRbh>VQgV?CMh6eZ*FsR03%^zV>vP~HDNGhH#jz9GdN)~F*Ig2GGt^jF=jVnVl_8m08A5e04fzaI&W}ga$$6DaxExhZ*FsRAX8&uY+-UHDIjBSZgX@1BVjQ#W;9|sGc{y3WMpA5GdE%}IXO2mHeoepWi@1CH#uVfOcQeeDiu09Z*XODVRUbDDkx)bZgX@XQ)6LlVR9xZAY*TCb94YBVKQc8V`MlnHD+WsHZwV4VKX;3WHVziG+||AIWcBqW@P|O6LSD66*@X^aAk5~bZ>GmC}VGKb95k6V_|GzawaJtV{dMAbO0k^GcqzWWoBh%I5IFXH#1{4V>dE6Fkv}0IWRCXGBh+bX8=qSa{wwAIy!G~WpZJ3Z*nU=C}VGKb95j{ZE$R5ZDnqBVRUJ4ZYC)JBVl4;H928pFk)t5WH~S}G-hFCI5#;oV>UT7W-(=BVmWC5OciqgDi=CBZ*XODVRUbDEj=h>Z*FsRAW3a-Y-Md_ZggREX>V>ODF7p3W@KSEGB7wWGdDLlG-WYlVmW4JWMN`3VPrC5V=^!>YXD3Ya{wwGIy!G~WpZJ3Z*nUrV{dMAbRbD>aBO95Wo~p~bZKvHCMh6eZ*FsR03%^zI5ae2Gh}6BWHmK0Ff}nZW@TbCV`VjAH8(XdWo0&P08ATm04g0iI&W}ga$$6DaxExhZ*FsRAW3a-Y-Md_ZggREX>V>ODIjBSZgX@1BVjl)VL4+lF*7%1WMnutGi5b6F*jj0VKOy2VlZZ6W;JgBOdE3mDib<7Z*XODVRUbDJv}I6Z*FsRAX8;*W+o{hV{dMAbO0k^V>LK3Vm4wiW;i)8F=S?DH8wb9Wo9{LI5II~W??iraR5vaIRGI-VRK~wLSb`dE@*UZY&QS^FLQZqbY*UHZ*neZ0CRb5bY*UHZ*pHaXf9}UZEQCH053^yWMz0RXaGrWWMz0?IA|_tbZu-m001vjd2MZFbaH89RAp{+Z*neZ08@EwZDn+FX=7AnZgX#PUpQzkXmo9CH2@z*a&K)^b#QED07i0eZB%t|Y-KKJbZu-+b!>ELaBpm7a{z5*Utef%ZDn6_b#88Da$k3Ea%*36d2MuMZgX#PUvqhFbY*UHZ*pH`Z)0C=b!>ELaBpm7b1rCfZET4E7dkpgZe(S603%^JFf?OhI50FdH)b|6V`e#FFkv<~FgIjkF*q?{Ib|`402ewsQFUQta&>TTY-KWL03%^xWHDngW;Qr5VlrefH)S$rWHB`{W;bJIW;ii5Vqr6h02ewsQFUQta&>TTY-KZM03%^$V=ypbW;SADF=Q|>WHT{kVKzB6GGR3`F=J#jWie%m02ewsPh)g-aBpm7GG+iHVKOo>Vq-QoWn(a7WHvM~H!?LeG-G8lWHVu5G+{DiF^K>dIyz5dbailVY-KZM03%^HHD+ZpHeqEjVPP~dFf(OgGBz|YHDfqrFlI7gWHvB~02ewsRAp{+Z*o&*adl;GV`Ts%VL3A}GcY(bWn?sEWHC5mF*Ic|Wn?%vW-~HoGcz-7>NKEAv!u_X>Db0b7^mGVQfimWNBk%b0}kPZgX@Xb97`nI&*1yWnXkAEFg1qWI8%?X?kT}bSVHMVKz8nWHx1HHZeG5VKg*hVPj-wH8wOjV`ODHW;kRvGKBy+ABg}LEIK-7Y+-asZe(S6D06gVIyzx;a$$KqNh}~zJ}e+}bYwa@b7^{IUvw-Wb97`nI&*1yWnXkD03%^$IXGi9V>o7JHD)k0GGb+8H#uT7Fl0G2Ff}ELaBpm7E@%Kvb!>ELaBpm7UpQzkXmo9C0v-V(0xJP90W|?T0YC#s14;!>1yTW609*iM0B3MvXJu|-ZDn(CVPj=ya&L8TV{Bn_b8~cZbz^jOZfS3Bba`-PWMyV#X>w+1Y-MJ3ZewI+W@&C^Wo~tCWo~tCAa-GFc42Y='); diff --git a/structstd_1_1tuple__element_3_01I_00_01T_01_4.html b/structstd_1_1tuple__element_3_01I_00_01T_01_4.html new file mode 100644 index 0000000..97ff71d --- /dev/null +++ b/structstd_1_1tuple__element_3_01I_00_01T_01_4.html @@ -0,0 +1,131 @@ + + + + + std::tuple_element<I, T> struct | symtensor + + + + + + + + + + + + + +
              +
              +
              +
              +
              +

              + +
              template<std::size_t I, symtensor::derived_from_template<symtensor::MultipoleBase> T>
              + std::tuple_element<I, T> struct +

              +

              tuple-element specialization to enable the use of structured bindings with multipoles

              + + + + + + + + + + + + + + +
              Template parameters
              Iindex of the element to retrieve the type of
              Tmultipole type. must be derived from a specialization of MultipoleBase, enforced by a concept
              +
              +
              +
              +
              + + + +
              + + diff --git a/structstd_1_1tuple__size_3_01T_01_4.html b/structstd_1_1tuple__size_3_01T_01_4.html new file mode 100644 index 0000000..f64387c --- /dev/null +++ b/structstd_1_1tuple__size_3_01T_01_4.html @@ -0,0 +1,127 @@ + + + + + std::tuple_size<T> struct | symtensor + + + + + + + + + + + + + +
              +
              +
              +
              +
              +

              + +
              template<symtensor::derived_from_template<symtensor::MultipoleBase> T>
              + std::tuple_size<T> struct +

              +

              tuple-size specialization to enable the use of structured bindings with multipoles

              + + + + + + + + + + +
              Template parameters
              Tmultipole type. must be derived from a specialization of MultipoleBase, enforced by a concept
              +
              +
              +
              +
              + + + +
              + + diff --git a/symtensor_8h.html b/symtensor_8h.html index 1439da9..57c1378 100644 --- a/symtensor_8h.html +++ b/symtensor_8h.html @@ -31,9 +31,10 @@