Skip to content

Latest commit

 

History

History
561 lines (433 loc) · 35.2 KB

README.md

File metadata and controls

561 lines (433 loc) · 35.2 KB
Raw

GATL: Geometric Algebra Template Library

GATL is a C++ library for Euclidean, homogeneous/projective, Mikowski/spacetime, conformal, and arbitrary geometric algebras.

Geometric algebra is a powerful mathematical system encompassing many mathematical concepts (e.g., complex numbers, quaternions algebra, Grassmann-Cayley algebra, and Plücker coordinates) under the same framework. Geometric algebra is mainly based on the algebraic system called Clifford algebra, but with a strong emphasis on geometric interpretation. In geometric algebra, subspaces are treated as primitives for computation. As such, it is an appropriate mathematical tool for modeling and solving geometric problems in physics, chemistry, engineering, and computer science.

GATL uses template meta-programming to implement the lazy evaluation strategy. This way, GATL is capable of performing some optimizations on the program at compile time. In other words, GATL is designed to automatically execute low-level algebraic manipulation in the procedures described by the users with geometric algebra operations, leading to more efficient programs.

Please, cite this book chapter if you use GATL in your research:

@InCollection{fernandes-SEMA-13-2021,
  title     = {Exploring lazy evaluation and compile-time simplifications for efficient geometric algebra computations},
  author    = {Fernandes, Leandro A. F.},
  chapter   = {6},
  pages     = {111--131},
  booktitle = {Systems, Patterns and Data Engineering with Geometric Calculi},
  editor    = {Xambó-Descamps, S.},
  volume    = {13},
  series    = {SEMA SIMAI Springer Series},
  publisher = {Springer, Cham},
  doi       = {https://doi.org/10.1007/978-3-030-74486-1_6},
  isbn      = {978-3-030-74485-4},
  e-isbn    = {978-3-030-74486-1},
  url       = {https://github.com/laffernandes/gatl},
  year      = {2021},
}

Let me know if you want to contribute to this project. Here you will find my contact information.

Contents:

  1. Requirements
  2. How to "Install" GATL
  3. Compiling Examples
  4. Compiling and Running Unit-Tests
  5. Documentation
  6. Related Project
  7. License

1. Requirements

Make sure that you have the following tools before attempting to use GATL.

Required tool:

  • Your favorite C++17 compiler.

Optional tool:

  • CMake to automate installation and to build and run examples and unit-tests.

GATL doesn't have any dependencies other than the C++ standard library.

2. How to "Install" GATL

GATL is a pure template library defined in the headers. Therefore, if you want to use GATL, you can use the header files right away. There is no binary library to link to and no configured header file.

Use the git clone command to download the project, where <gatl-dir> must be replaced by the directory in which you want to place GATL's source code, or removed <gatl-dir> from the command line to download the project to the ./gatl directory:

git clone https://github.com/laffernandes/gatl.git <gatl-dir>

The directory <gatl-dir>/cpp/include must be in the include path of your program, i.e., you have to use the -I<gatl-dir>/cpp/include option flag while compiling your program. Alternatively, you can use CMake to copy GATL's header files to the common include directory in your system (e.g., /usr/local/include, in Linux) to avoid the use of the -I<gatl-dir>/cpp/include option flag. The basic steps for installing GATL using CMake look like this:

cd <gatl-dir>/cpp
mkdir build
cd build
cmake ..

If you are using CMake to handle builds of your program, then it is strongly recommended to use the commands above to install GATL. After installation CMake will find GATL using the command find_package(GATL) (see CMake documentation for details). In addition, you will be able to use the GATL_INCLUDE_DIRS variable in the CMakeList.txt file of your program while defining the include directories of your project or targets.

3. Compiling Examples

The basic steps for configuring and building GATL examples look like this:

cd <gatl-dir>/cpp/tools/example
mkdir build
cd build
cmake ..
cmake --build . --config Release

Recall that <gatl-dir> is the directory in which you placed GATL's source code.

The executable files produced by the last command start with gatl_example_.

4. Compiling and Running Unit-Tests

Unit-tests are under construction. Please, don't try to build them.

5. Documentation

Here you find a brief description of the namespaces, macros, classes, functions, procedures, and operators available for the user. The detailed documentation is not ready yet.

According to GATL conventions, in the following definitions, lhs and rhs are informal shorthand for, respectively, the left-hand side and the right-hand side arguments of binary procedures. In addition, the mtr argument must be an instance of the metric_space<...> class, while all other arguments can be either an instances of the clifford_expression<...> class or other numerical types (e.g., double, float, int, or instances of third-party classes). Numerical types are automatically converted by GATL to scalar Clifford expression using the scalar function.

Contents:

Namespaces

Namespaces are declarative regions that provide scope to the names of the types, function, variables, etc., inside it. GATL defines the following namespaces.

Namespace Description
ga The main namespace that encloses all GATL implementations
ga1e, ga2e, ga3e, ga4e, ga5e The namespace of Euclidean geometric algebra of Rn
ga1h, ga2h, ga3h, ga4h The namespace of homogeneous/projective geometric algebra of Rd (n = d + 1)
ga1p, ga2p, ga3p, ga4p The namespace of plane-based geometric algebra of Rd (n = d + 1)
ga1m, ga2m, ga3m The namespace of Mikowski/spacetime algebra of Rd (n = d + 2)
ga1c, ga2c, ga3c The namespace of conformal geometric algebra of Rd (n = d + 2)

The namespaces of specific geometric algebras (e.g., ga3e, ga3h, ga3m, and ga3c) already use the ga namespace. In addition, they overload all metric operations presented in the following section by setting the mtr argument according to their respective spaces.

All above-mentioned namespaces declare a nested detail namespace. This is the namespace where the magic happens. Don't touch it!

According to the GATL conventions, the root directory for the header files that you will include in your program is the gatl folder. Also, the header file for each namespace is its name followed by the .hpp extension. Putting both conventions together, we have gatl/ga.hpp, gatl/ga3e.hpp, gatl/ga3h.hpp, gatl/ga3m.hpp, gatl/ga3c.hpp, and so on.

Macros

Optionally, set the following macros before including GATL headers in your program to change some conventions of the library.

Class Description
GA_DEFAULT_FLOATING_POINT_TYPE Defines the floating-point type assumed as default by the library (default is std::double_t)
GA_DEFAULT_INTEGRAL_TYPE Defines the signed integral type assumed as default by the library (default is std::int64_t)
GA_MAX_BASIS_VECTOR_INDEX Defines the maximum number of basis vectors assumed while performing algebraic manipulations and setting the size of bitsets (default is 63)

Classes and Data Types

The following basic data types are defined in order to assign a meaning to conventional types, like double, int, and so on.

Basic Type Description
default_floating_point_t The floating point type assumed as default by the library (see GA_DEFAULT_FLOATING_POINT_TYPE)
default_integral_t The signed integral type assumed as default by the library (see GA_DEFAULT_INTEGRAL_TYPE)
bitset_t The bitset type used by the library (uses GA_MAX_BASIS_VECTOR_INDEX to select the smallest unsigned integral type capable to meet implementation requirements)
grade_t The signed integral type used to represent grade values (same as default_integral_t)
index_t The unsigned integral type used to represent the index of basis vectors (set to std::uint64_t)
ndims_t The unsigned integral type used to represent the number of dimensions of the vector space (same as index_t)
associative_container_t<ValueType> The associative container class used by the clifford_expression<...> class to store components of multivectors (set to std::map<bitset_t, ValueType>)
sequence_container_t<EntryType, Size> The sequence container class used by the clifford_expression<...> class to store components of multivectors (set to std::array<EntryType, Size>)

The following classes correspond to the most important structures of GATL.

Class Description
clifford_expression<CoefficientType, Expression> A Clifford expression
grade_result<Value> A class to encode the result of the grade function
lazy_context<InputTypes...> A class to define lazy arguments for lazy evaluation of Clifford expressions
metric_space<MetricSpaceType> The base metric space class
Exception Class Description
bad_checked_copy_exception An exception of this type is thrown when a checked copy fails
not_implemented_error An exception to report errors related to not implemented features

For the sake of simplicity, GATL provides the following set of class aliases and helper meta-functions to assist type definition. Nevertheless, it is strongly recommended to use the auto placeholder type specifier (please, refer to the C++ specification for details) whenever possible.

Class Alias Description
constant<CoefficientType, IntegralValue> An alias for constant scalar Clifford expressions whose coefficient is known in compile time
scalar_clifford_expression<CoefficientType, Coefficient> An alias for scalar Clifford expressions
Helper for Practical Type Definition Description
full_multivector_t<CoefficientType, VectorSpaceDimensions [, FirstGrade [, LastGrade]]> Helper for defining a Clifford expression representing a general multivector with runtime defined coefficients over an n-dimensional vector space
full_derived_multivector_t<CoefficientType, Expression> Helper for defining a Clifford expression representing a general multivector with runtime defined coefficients in all components of the given Clifford expression
full_kvector_t<CoefficientType, VectorSpaceDimensions, Grade> Helper for defining a Clifford expression representing a k-vector with runtime defined coefficients over an n-dimensional vector space
full_vector_t<CoefficientType, VectorSpaceDimensions> Helper for defining a Clifford expression representing a vector with runtime defined coefficients over an n-dimensional vector space
scaled_constant_basis_blade_t<CoefficientType, Indices...> Helper for defining a Clifford expression representing a scaled compile-time defined basis blade
scaled_constant_basis_vector_t<CoefficientType, Index> Helper for defining a Clifford expression representing a scaled compile-time defined basis vector
scaled_basis_blade_t<CoefficientType, FirstPossibleGrade[, LastPossibleGrade]> Helper for defining a Clifford expression representing a scaled runtime defined basis blade
scaled_basis_vector_t<CoefficientType> Helper for defining a Clifford expression representing a scaled runtime defined basis vector
scaled_scalar_t<CoefficientType> Helper for defining a Clifford expression representing a scalar value whose coefficient is unknown in compile time
scaled_pseudoscalar_t<CoefficientType, N> Helper for defining a Clifford expression representing a scaled compile-time defined pseudoscalar
unit_constant_basis_blade_t<Indices...> Helper for defining a Clifford expression representing an unit compile-time defined basis blade
unit_constant_basis_vector_t<Index> Helper for defining a Clifford expression representing an unit compile-time defined basis vector
unit_basis_blade_t<FirstPossibleGrade [, LastPossibleGrade]> Helper for defining a Clifford expression representing an unit runtime defined basis blade
unit_basis_vector_t Helper for defining a Clifford expression representing an unit runtime defined basis vector
unit_pseudoscalar_t<N> Helper for defining a Clifford expression representing an unit compile-time defined pseudoscalar

Utilities Constants and Functions

Here you find some useful meta-constants and functions to assist the implementation of your program.

Constant Description
c<IntegralValue [, CoefficientType]> Defines a constant scalar Clifford expression whose coefficient is known in compile time
Function Description
make_lazy_context(inputs...) Creates a lazy_context<InputTypes...> object
make_lazy_context_tuple(inputs...) Creates a std::tuple object made of K + 1 entries, where the first is a lazy_context<InputTypes...> object and the next K entries are the lazy input arguments
e(index) Returns a runtime defined unit basis vector (index values can be set using c<IntegralValue>, too)
scalar(arg) Converts the given numerical value to a scalar Clifford expression
pseudoscalar([mtr]) Returns the compile-time defined unit pseudoscalar of the given metric space
vector([mtr,] coords...) Makes a vector with the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
vector([mtr,] begin, end) Makes a vector with the set of coordinates accessed by the iterators

Products and Basic Operations

The following tables present a set of basic products and operations from geometric algebra.

Product Description
cp(lhs, rhs [, mtr]) Commutator product
dp(lhs, rhs [, tol] [, mtr]) Delta product
dot(lhs, rhs [, mtr]) Dot product
gp(lhs, rhs [, mtr]) Geometric/Clifford product
hip(lhs, rhs [, mtr]) Hestenes inner product
igp(lhs, rhs [, mtr]) Inverse geometric/Clifford product (the argument rhs must be a versor)
lcont(lhs, rhs [, mtr]) Left contraction
op(lhs, rhs [, mtr]) Outer/Wedge product
rp(lhs, rhs [, mtr]) Regressive product
rcont(lhs, rhs [, mtr]) Right contraction
sp(lhs, rhs [, mtr]) Scalar product
Sign-Change Operation Description
conjugate(arg) Clifford conjugation
involute(arg) Grade involution
reverse(arg) Reversion
Dualization Operation Description
dual(arg [, pseudoscalar [, mtr]]) Dualization operation
undual(arg [, pseudoscalar [, mtr]]) Undualization operation
Norm-Based Operation Description
rnorm_sqr(arg [, mtr]) Squared reverse norm
rnorm(arg [, mtr]) Reverse norm
inv(arg [, mtr]) Inverse of the given versor using the squared reverse norm
unit(arg [, mtr]) Unit under reverse norm
Transformation Operation Description
apply_even_versor(versor, arg [, mtr]) Returns the argument transformed by the even versor using the sandwich product
apply_odd_versor(versor, arg [, mtr]) Returns the argument transformed by the odd versor using the sandwich product
apply_rotor(rotor, arg [, mtr]) Returns the argument transformed by the rotor using the sandwich product
Blade Operation Description
fast_join(lhs, rhs [, tol] [, mtr]) Returns the join of the given pair of blades using the algorithm developed by Fontijne (2008)
fast_meet_and_join(lhs, rhs [, tol] [, mtr]) Returns a std::tuple<T1, T2> structure where T1 is the meet and T2 is the join of the given pair of blades using the algorithm developed by Fontijne (2008)
fast_plunge(lhs, rhs [, tol] [, mtr]) Returns the plunge of the given pair of blades as described by Dorst et al. (2007), and implemented using the fast_join function
meet_and_join(lhs, rhs [, tol] [, mtr]) Returns a std::tuple<T1, T2> structure where T1 is the meet and T2 is the join of the given pair of blades using the algorithm described by Dorst et al. (2007)
plunge(lhs, rhs [, tol] [, mtr]) Returns the plunge of the given pair of blades as described by Dorst et al. (2007), and implemented using the meet_and_join function
Misc Operation Description
grade(arg [, tol]) Returns a grade_result<Value> structure encoding the grade of the given argument
largest_grade(arg [, tol]) Returns a scalar expression with the largest grade part of the argument, such that it is not zero
take_grade(arg, k) Returns the k-grade part of the argument
take_largest_grade(arg [, tol]) Returns the portion of the argument with the largest grade

Overloaded Operators

GATL overload some C++ operators to make the writing of source code closer to the writing of mathematical expressions with geometric algebra.

It is important to notice that the precedence and associativity of C++ operators are different than the one assumed in mathematical functions. For instance, one would expect that the outer/wedge product ^ would be evaluated before the addition operation in the following expression a + b ^ c, because product precedes addition in math. However, in C++ the addition operator (+) precedes the bitwise XOR operator (^), leading to possible mistakes while implementing mathematical procedures (please, refer to the C++ specification for details). As a result, the resulting expression in this example would be (a + b) ^ c. The use of parenthesis is strongly recommended in order to avoid those mistakes. By rewriting the example, a + (b ^ c) will guarantee the expected behavior.

Arithmetic Operator Description
+rhs Unary plus
-rhs Unary minus
~rhs Reversion (same as reverse(rhs))
lhs + rhs Addition
lhs - rhs Subtraction
lhs * rhs Geometric/Clifford product (same as gp(lhs, rhs))
lhs / rhs Inverse geometric/Clifford product (same as igp(lhs, rhs))
lhs ^ rhs Outer/Wedge product (same as op(lhs, rhs))
lhs < rhs Left constraction (same as lcont(lhs, rhs))
lhs > rhs Right constraction (same as rcond(lhs, rhs))
lhs | rhs Dot product (same as dot(lhs, rhs))
Input/Output Operator Description
os << arg Insert formatted output (it uses the write function)

Overloaded Mathematical Functions

The following tables present the C++ mathematical functions overloaded by GATL to accept Clifford expressions as input.

Trigonometric Function Description
cos(arg) Cosine of the scalar argument (in radians)
sin(arg) Sine of the scalar argument (in radians)
tan(arg) Tangent of the scalar argument (in radians)
Hyperbolic Function Description
cosh(arg) Hyperbolic cosine of the scalar argument (in radians)
sinh(arg) Hyperbolic sine of the scalar argument (in radians)
tanh(arg) Hyperbolic tangent of the scalar argument (in radians)
Exponential and Logarithmic Function Description
exp(arg [, tol] [, mtr]) Base-e exponential function of the even blade argument
log(arg) Natural logarithm of the scalar argument
Power Function Description
pow(base, exponent) Scalar argument base raised to the scalar power argument exponent
cbrt(arg) Cubic root of the scalar argument
sqrt(arg) Square root of the scalar argument
Other Function Description
abs(arg) Absolute value of the scalar argument

Tools

GATL includes a set of useful functions, procedures, and meta-functions to help developers to write their programs.

Function Description
default_tolerance<ValueType>() Return the standard tolerance value tol assumed for the given value type
for_each_basis_vector(arg, f) Applies the given function object f to the result of dereferencing every basis vector in the given Clifford expression comprised of a single component
for_each_component(arg, f) Applies the given function object f to the result of dereferencing every component in the given Clifford expression
write(os, expression, basis_vectors) Writes the given Clifford expression into the output stream os using the given set of basis vectors
Testing Function Description
is_null(arg [, tol] [, mtr]) Returns whether the given argument is a null multivector
is_unit(arg [, tol] [, mtr]) Returns whether the given argument is an unit multivector
is_zero(arg [, tol]) Returns whether the given argument is equal to zero
Copy Procedure Description
checked_trivial_copy(input, result, [, tol]) Copies the coefficients of the input argument into the result argument when it is possible to perform runtime-checked trivial copy
trivial_copy(input, result, [, tol]) Copies the coefficients of the input argument into the result argument when it is possible to perform a trivial copy
Meta-Function Description
largest_possible_grade_v<Expression> Helper to deduce the largest possible grade value in the given Expression parameter extracted from a Clifford expression
smallest_possible_grade_v<Expression> Helper to deduce the smallest possible grade value in the given Expression parameter extracted from a Clifford expression
Testing Meta-Function Description
is_clifford_expression_v<Type> Returns whether the given type is a Clifford expression
is_metric_space_v<Type> Returns whether the given type is a metric space type
is_general_metric_space_v<MetricSpaceType> Returns whether the given metric space is general
is_orthogonal_metric_space_v<MetricSpaceType> Returns whether the given metric space is orthogonal

Algebra-Specific Declarations

In the following sub-section, you find declarations that are specific of the respective geometric algebra.

Signed

Classes and constants of signed geometric algebras of Rp, q, r.

Class Description
signed_metric_space<P, Q, R> Orthogonal metric space with signature (p, q, r) (n = p + q + r)
Constant Value Description
_0, _1, _2 Zero, one, and two, respectively (same as c<0>, c<1>, and c<2>, respectively)
I Unit pseudoscalar (same as pseudoscalar())
space An instance of the orthogonal metric space class with signature (p, q, r)

Euclidean

Classes, constants, functions, and operations of Euclidean geometric algebras of Rn. They are available in the following namespaces: ga1e, ga2e, ga3e, ga4e, and ga5e.

Class Description
euclidean_metric_space<N> Euclidean metric space
Constant Value Description
_0, _1, _2 Zero, one, and two, respectively (same as c<0>, c<1>, and c<2>, respectively)
e1, e2, ..., eN Euclidean basis vector (same as e(c<1>), e(c<2>), ..., e(c<N>))
I Unit pseudoscalar (same as pseudoscalar())
Ie Unit pseudoscalar of the Euclidean portion of the vector space (same as I)
space An instance of the Euclidean metric space class
Function Description
euclidean_vector([mtr,] coords...) Makes an Euclidean vector with the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
euclidean_vector([mtr,] begin, end) Makes an Euclidean vector with the set of coordinates accessed by the iterators
Operation Description
project(lhs, rhs [, mtr]) Orthogonal projection of blade lhs ontho blade rhs
reject(lhs, rhs [, mtr]) Rejection of blade lhs by blade rhs

Homogeneous/Projective

Classes, constants, functions, and operations of homogeneous/projective geometric algebras of Rd (n = d + 1). They are available in the following namespaces: ga1h, ga2h, ga3h, and ga4h.

Class Description
homogeneous_metric_space<D> Homogeneous/Projective metric space
Constant Value Description
_0, _1, _2 Zero, one, and two, respectively (same as c<0>, c<1>, and c<2>, respectively)
e1, e2, ..., eD Euclidean basis vector (same as e(c<1>), e(c<2>), ..., e(c<D>))
ep Positive extra basis vector interpreted as the point at the origin (same as e(c<D + 1>))
I Unit pseudoscalar (same as pseudoscalar())
Ie Unit pseudoscalar of the Euclidean portion of the vector space (same as rcont(I, ep))
space An instance of the homogeneous/projective metric space class
Function Description
euclidean_vector([mtr,] coords...) Makes an Euclidean vector with the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
euclidean_vector([mtr,] begin, end) Makes an Euclidean vector with the set of coordinates accessed by the iterators
point([mtr,] coords...) Makes an unit point using the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
point([mtr,] begin, end) Makes an unit point using the set of coordinates accesses by the iterators
Parameter Function Description
flat_direction(flat [, mtr]) The direction parameter of a given flat
flat_moment(flat [, mtr]) The moment parameter of a given flat
flat_support_vector(flat [, mtr]) The support vector parameter of a given flat
flat_unit_support_point(flat [, mtr]) The unit support point parameter of a given flat
Transformation Operation Description
translate(direction, flat [, mtr]) Translate the given flat to a given direction

Plane-Based

Classes, constants, functions, and operations of plane-based geometric algebras of Rd (n = d + 1). They are available in the following namespaces: ga1p, ga2p, ga3p, and ga4p.

Class Description
plane_based_metric_space<D> Plane-based geometric algebra metric space
Constant Value Description
_0, _1, _2 Zero, one, and two, respectively (same as c<0>, c<1>, and c<2>, respectively)
e1, e2, ..., eD Euclidean basis vector (same as e(c<1>), e(c<2>), ..., e(c<D>))
e0 Null extra basis vector (same as e(c<D + 1>))
I Unit pseudoscalar (same as pseudoscalar())
space An instance of the plane-based geometric algebra metric space class
Function Description
euclidean_vector([mtr,] coords...) Makes an Euclidean vector with the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
euclidean_vector([mtr,] begin, end) Makes an Euclidean vector with the set of coordinates accessed by the iterators

Mikowski/Spacetime

Classes, constants, functions, and operations of Mikowski/spacetime geometric algebras of Rd (n = d + 2). They are available in the following namespaces: ga1m, ga2m, and ga3m.

Class Description
minkowski_metric_space<D> Minkowski/Spacetime metric space
Constant Value Description
_0, _1, _2 Zero, one, and two, respectively (same as c<0>, c<1>, and c<2>, respectively)
e1, e2, ..., eD Euclidean basis vector (same as e(c<1>), e(c<2>), ..., e(c<D>))
ep Positive extra basis vector (same as e(c<D + 1>))
em Negative extra basis vector (same as e(c<D + 2>))
no Null vector interpreted as the point at the origin (same as (em - ep) / c<2>)
ni Null vector interpreted as the point at infinity (same as ep + em)
I Unit pseudoscalar (same as pseudoscalar())
Ie Unit pseudoscalar of the Euclidean portion of the vector space (same as rcont(I, ep ^ em))
space An instance of the Minkowski/spacetime metric space class
Function Description
euclidean_vector([mtr,] coords...) Makes an Euclidean vector with the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
euclidean_vector([mtr,] begin, end) Makes an Euclidean vector with the set of coordinates accessed by the iterators
point([mtr,] coords...) Makes an unit point using the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
point([mtr,] begin, end) Makes an unit point using the set of coordinates accesses by the iterators
Parameter Function Description
primal_flat_direction(primal_flat [, mtr]), dual_flat_direction(dual_flat [, mtr]) The direction parameter of a given primal/dual flat
primal_flat_location(primal_flat [, mtr]), dual_flat_location(primal_flat [, mtr]) The location parameter of a given primal/dual flat
primal_round_direction(primal_round [, mtr]), dual_round_direction(primal_round [, mtr]) The direction parameter of a given primal/dual round
primal_round_location(primal_round [, mtr]), dual_round_location(dual_round [, mtr]) The location parameter of a given primal/dual round
primal_round_size_sqr(primal_round [, mtr]), dual_round_size_sqr(primal_round [, mtr]) The squared size parameter of a given primal/dual round
primal_tangent_direction(primal_tangent [, mtr]), dual_tangent_direction(primal_tangent [, mtr]) The direction parameter of a given primal/dual tangent
primal_tangent_location(primal_tangent [, mtr]), dual_tangent_location(dual_tangent [, mtr]) The location parameter of a given primal/dual tangent

Conformal

Classes, constants, functions, and operations of conformal geometric algebras of Rd (n = d + 2). They are available in the following namespaces: ga1c, ga2c, and ga3c.

Class Description
conformal_metric_space<D> Conformal metric space
Constant Value Description
_0, _1, _2 Zero, one, and two, respectively (same as c<0>, c<1>, and c<2>, respectively)
e1, e2, ..., eD Euclidean basis vector (same as e(c<1>), e(c<2>), ..., e(c<D>))
no Null vector interpreted as the point at the origin (same as e(c<D + 1>))
ni Null vector interpreted as the point at infinity (same as e(c<D + 2>))
ep Positive extra basis vector (same as (ni / c<2>) - no)
em Negative extra basis vector (same as (ni / c<2>) + no)
I Unit pseudoscalar (same as pseudoscalar())
Ie Unit pseudoscalar of the Euclidean portion of the vector space (same as rcont(I, no ^ ni))
space An instance of the conformal metric space class
Function Description
euclidean_vector([mtr,] coords...) Makes an Euclidean vector with the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
euclidean_vector([mtr,] begin, end) Makes an Euclidean vector with the set of coordinates accessed by the iterators
point([mtr,] coords...) Makes an unit point using the given set of coordinates (coordinate values can be set using c<IntegralValue>, too)
point([mtr,] begin, end) Makes an unit point using the set of coordinates accesses by the iterators
Parameter Function Description
primal_flat_direction(primal_flat [, mtr]), dual_flat_direction(dual_flat [, mtr]) The direction parameter of a given primal/dual flat
primal_flat_location(primal_flat [, mtr]), dual_flat_location(primal_flat [, mtr]) The location parameter of a given primal/dual flat
primal_round_direction(primal_round [, mtr]), dual_round_direction(primal_round [, mtr]) The direction parameter of a given primal/dual round
primal_round_location(primal_round [, mtr]), dual_round_location(dual_round [, mtr]) The location parameter of a given primal/dual round
primal_round_size_sqr(primal_round [, mtr]), dual_round_size_sqr(primal_round [, mtr]) The squared size parameter of a given primal/dual round
primal_tangent_direction(primal_tangent [, mtr]), dual_tangent_direction(primal_tangent [, mtr]) The direction parameter of a given primal/dual tangent
primal_tangent_location(primal_tangent [, mtr]), dual_tangent_location(dual_tangent [, mtr]) The location parameter of a given primal/dual tangent

General

Classes, constants, functions, and operations of general geometric algebras defined by the used. The are available by including gatl/ga.hpp and gatl/ga/model/general.hpp.

Class Description
general_metric_space<MetricMatrixEntries...> General metric space
Helper for Practical Type Definition Description
constant_general_metric_space_t<MetricMatrixValues...> Helper for defining a general geometric algebra model with a metric matrix comprised of constant integer values

6. Related Project

Please, visit the GitHub repository of the ga-benchmark project for a benchmark comparing the most popular libraries, library generators, and code optimizers for geometric algebra.

7. License

This software is licensed under the GNU General Public License v3.0. See the LICENSE file for details.