HodgeTester< Calculus, order > Struct Template Reference

#include </home/runner/work/DGtal/DGtal/tests/dec/DECCommon.h>

Public Member Functions
	BOOST_STATIC_ASSERT ((order<=Calculus::dimensionEmbedded))

Static Public Member Functions
static bool	test (const Calculus &calculus)

Detailed Description

template<typename Calculus, int order>
struct HodgeTester< Calculus, order >

Definition at line 55 of file DECCommon.h.

Member Function Documentation

BOOST_STATIC_ASSERT()

template<typename Calculus , int order>

HodgeTester< Calculus, order >::BOOST_STATIC_ASSERT

(

(order<=Calculus::dimensionEmbedded)

)

test()

template<typename Calculus , int order>

static bool HodgeTester< Calculus, order >::test ( const Calculus &  calculus )

inlinestatic

Definition at line 59 of file DECCommon.h.

    {
        DGtal::trace.info() << "testing identity operators " << order << std::endl;
 
        { // test identity operator
            typedef DGtal::LinearOperator<Calculus, order, DGtal::PRIMAL, order, DGtal::PRIMAL> PrimalIdentity;
            PrimalIdentity primal_identity = calculus.template identity<order, DGtal::PRIMAL>();
            if (!is_identity(primal_identity.myContainer, 1)) return false;
 
            typedef DGtal::KForm<Calculus, order, DGtal::PRIMAL> SolveForm;
            SolveForm input(calculus);
            SolveForm output = primal_identity * input;
            typedef typename Calculus::LinearAlgebraBackend LinearAlgebraBackend;
            typedef typename LinearAlgebraBackend::SolverConjugateGradient LinearSolver;
            typedef DGtal::DiscreteExteriorCalculusSolver<Calculus, LinearSolver, order, DGtal::PRIMAL, order, DGtal::PRIMAL> Solver;
            Solver solver;
            SolveForm input_solved = solver.compute(primal_identity).solve(output);
            //if (input_solved != input) return false;
 
            typedef DGtal::LinearOperator<Calculus, order, DGtal::DUAL, order, DGtal::DUAL> DualIdentity;
            DualIdentity dual_identity = calculus.template identity<order, DGtal::DUAL>();
            if (!is_identity(dual_identity.myContainer, 1)) return false;
        }
 
        typedef DGtal::LinearOperator<Calculus, order, DGtal::PRIMAL, Calculus::dimensionEmbedded-order, DGtal::DUAL> PrimalHodge;
        typedef DGtal::LinearOperator<Calculus, Calculus::dimensionEmbedded-order, DGtal::DUAL, order, DGtal::PRIMAL> DualHodge;
        const PrimalHodge primal_hodge = calculus.template hodge<order, DGtal::PRIMAL>();
        const DualHodge dual_hodge= calculus.template hodge<Calculus::dimensionEmbedded-order, DGtal::DUAL>();
 
        DGtal::trace.info() << "testing primal to primal hodge composition order " << order << std::endl;
 
        { // test primal to primal composition
            typedef DGtal::LinearOperator<Calculus, order, DGtal::PRIMAL, order, DGtal::PRIMAL> PrimalPrimal;
            PrimalPrimal primal_primal = dual_hodge * primal_hodge;
            if (!is_identity(primal_primal.myContainer, pow(-1, order*(Calculus::dimensionEmbedded-order)))) return false;
        }
 
        DGtal::trace.info() << "testing dual to dual hodge composition order " << order << std::endl;
 
        { // test dual to dual composition
            typedef DGtal::LinearOperator<Calculus, Calculus::dimensionEmbedded-order, DGtal::DUAL, Calculus::dimensionEmbedded-order, DGtal::DUAL> DualDual;
            DualDual dual_dual = primal_hodge * dual_hodge;
            if (!is_identity(dual_dual.myContainer, pow(-1, order*(Calculus::dimensionEmbedded-order)))) return false;
        }
 
        return HodgeTester<Calculus, order-1>::test(calculus);
    }

References calculus, DGtal::DiscreteExteriorCalculusSolver< TCalculus, TLinearAlgebraSolver, order_in, duality_in, order_out, duality_out >::compute(), DGtal::DUAL, DGtal::Trace::info(), DGtal::PRIMAL, DGtal::DiscreteExteriorCalculusSolver< TCalculus, TLinearAlgebraSolver, order_in, duality_in, order_out, duality_out >::solve(), and DGtal::trace.

---

The documentation for this struct was generated from the following file:

• DECCommon.h