meta_math.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
#include <kernel/util/assertion.hpp>
 
namespace FEAT
{
  namespace MetaMath
  {
    template<int n_, int m_ = 0>
    struct Factorial
    {
      // Ensure that the parameter m_ is non-negative. The case n_ = 0 is handled by specialization below.
      static_assert(m_ >= 0, "parameter m_ must be non-negative");
      // Ensure that n_ >= m_. The case m_ = n_ is handled by partial specialization below.
      static_assert(n_ > m_, "parameter m_ must not be greater than parameter n_");
 
      static constexpr int value = n_ * Factorial<n_ - 1, m_>::value;
    }; // struct Factorial<n_,m_>
 
    // partial specialization for n_ = m_
    template<int n_>
    struct Factorial<n_, n_>
    {
      static_assert(n_ >= 0, "parameters n_ = m_ must be non-negative");
      static constexpr int value = n_;
    }; // struct Factorial<n_,n_>
 
    // explicit specialization for n_ = m_ = 0; the partial specialization above for n_ = m_ would return 0
    template<>
    struct Factorial<0, 0>
    {
      static constexpr int value = 1;
    }; // struct Factorial<0,0>
 
    template<int n_, int k_>
    struct Binomial
    {
      // note: the valid cases k_ = 0 and k_ = n_ are specialized below
      static_assert(k_ > 0, "parameter k_ must be non-negative");
      static_assert(n_ > k_, "parameter k_ must not be greater than parameter n_");
 
      // (n,k) = (n-1,k-1) + (n-1, k)
      static constexpr int value = Binomial<n_-1,k_-1>::value + Binomial<n_-1,k_>::value;
    }; // struct Binomial<n_,k_>
 
    // partial specialization for k_ = n_
    template<int n_>
    struct Binomial<n_,n_>
    {
      static_assert(n_ > 0, "parameter n_ must be non-negative");
      static constexpr int value = 1;
    };
 
    // partial specialization for k_ = 0
    template<int n_>
    struct Binomial<n_, 0>
    {
      static_assert(n_ > 0, "parameter n_ must be non-negative");
      static constexpr int value = 1;
    };
 
    // explicit specialization for k_ = n_ = 0; this is only needed for disambiguation
    template<>
    struct Binomial<0, 0>
    {
      static constexpr int value = 1;
    };
  } // namespace MetaMath
} // namespace FEAT