MathToolbox.hpp

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
  Copyright (C) 2015 by Andreas Lauser

  This file is part of the Open Porous Media project (OPM).

  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.

  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OPM_MATERIAL_MATH_TOOLBOX_HPP
#define OPM_MATERIAL_MATH_TOOLBOX_HPP

#include <cmath>
#include <algorithm>
#include <type_traits>

namespace Opm {
template <class Evaluation, bool isScalar = std::is_floating_point<Evaluation>::value >
struct MathToolbox;

template <class LhsEval, class RhsEval,
          bool lhsIsScalar = std::is_floating_point<LhsEval>::value,
          bool rhsIsScalar = std::is_floating_point<RhsEval>::value>
struct ToLhsEvalHelper;

template <class LhsEval, class RhsEval>
struct ToLhsEvalHelper<LhsEval, RhsEval, true, true> {
    static LhsEval exec(const RhsEval& eval)
    { return eval; }
};

template <class LhsEval, class RhsEval>
struct ToLhsEvalHelper<LhsEval, RhsEval, true, false> {
    static LhsEval exec(const RhsEval& eval)
    { return eval.value; }
};

template <class LhsEval, class RhsEval>
struct ToLhsEvalHelper<LhsEval, RhsEval, false, false> {
    static LhsEval exec(const RhsEval& eval)
    { return eval; }
};

/*
 * \brief A traits class which provides basic mathematical functions for arbitrary scalar
 *        floating point values.
 *
 * The reason why this is done in such a complicated way is to enable other approaches,
 * in particular automatic differentiation based ones.
 */
template <class ScalarT>
struct MathToolbox<ScalarT, true>
{
public:
    typedef ScalarT Scalar;

    typedef ScalarT Evaluation;

    static Scalar value(const Evaluation& eval)
    { return eval; }

    static Scalar createConstant(Scalar value)
    { return value; }

    static Scalar createVariable(Scalar value, int /* varIdx */)
    { return value; }

    template <class LhsEval>
    static LhsEval toLhs(const Evaluation& eval)
    { return ToLhsEvalHelper<Evaluation, LhsEval>::exec(eval); }

    static Scalar passThroughOrCreateConstant(Scalar value)
    { return value; }

    // arithmetic functions

    static Scalar max(Scalar arg1, Scalar arg2)
    { return std::max(arg1, arg2); }

    static Scalar min(Scalar arg1, Scalar arg2)
    { return std::min(arg1, arg2); }

    static Scalar abs(Scalar arg)
    { return std::abs(arg); }

    static Scalar tan(Scalar arg)
    { return std::tan(arg); }

    static Scalar atan(Scalar arg)
    { return std::atan(arg); }

    static Scalar atan2(Scalar arg1, Scalar arg2)
    { return std::atan2(arg1, arg2); }

    static Scalar sin(Scalar arg)
    { return std::sin(arg); }

    static Scalar asin(Scalar arg)
    { return std::asin(arg); }

    static Scalar cos(Scalar arg)
    { return std::cos(arg); }

    static Scalar acos(Scalar arg)
    { return std::acos(arg); }

    static Scalar sqrt(Scalar arg)
    { return std::sqrt(arg); }

    static Scalar exp(Scalar arg)
    { return std::exp(arg); }

    static Scalar log(Scalar arg)
    { return std::log(arg); }

    static Scalar pow(Scalar base, Scalar exp)
    { return std::pow(base, exp); }
};

} // namespace Opm

#endif