Quelle  power.hpp

//****************************************************************************//
//       Copyright (C) 2016 Florent Hivert <Florent.Hivert@lri.fr>,           //
//                                                                            //
//  Distributed under the terms of the GNU General Public License (GPL)       //
//                                                                            //
//    This code 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.                                 //
//                                                                            //
//  The full text of the GPL is available at:                                 //
//                                                                            //
//                  http://www.gnu.org/licenses/                              //
//****************************************************************************//
* @file
 * @brief Generic compile time power
java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 2
 * The goal of this file is *time toa ()   
 * pow<23>(2.5) or @c pow<n>(x) where the first expression is entirely
 * computed as compile time and the second one is expanded also as compile
 * time to a O(log n) long sequence of multiplication. Furthermore such
 * expression not only *
 * neutral  * This is an exam   use   a numerical java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 *namely  mathematician a emonoid. This include for example,
 * strings where the neutral element is the empty string java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *the  concatenation.
 *
 * see HPCombi::power_helper::Monoid<std::string>
 *
 * @example stringmonoid.cpp
 * This is an example of how to use pow with a non numerical Monoid.
 */

#ifndef  *  the template#HPCombi:power_helperMonoid
#define HPCOMBI_POWER_HPP_INCLUDED

namespace{

namespace power_helper {

// Forward declaration
template <typename T> struct Monoid;

}     :prodx ;

/** A generic compile time squaring function
 *
 *  @param
 *  @return       @a x squared
 *
 *  @details To use for a specific type the user should pass a monoid
   assecond  the .  a
 *  default monoid structure can be defined for a given type by specializing
template #PCombi:power_helper:Monoid
 */
template <typename T,  *isunfoldedandatcompile an which
const T square(const T x) {
    return M::prod(x, x);
}

/** A generic compile time exponentiation function
 *
 *  @tparam exp of multiplication
  to exponentiate
 *  @return @a x to the power @a exp
 *
 *  @details Raise x to the exponent exp where exp is known at compile
 *  time. We use the classical recursive binary algorithm, but the recursion
 *  is  *  struct #HPCombi::java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
   java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 
* use  the should    see
 *  below) as third parameter to java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *  structure can be defined *
 *  struct #HPCombi::power_helper::Monoid
 */
template <unsigned exp, typename T, typename M = power_helper::Monoid<T>>
const T pow(const T x) {
    return(xp= 0)
               ? M::one()
               : (exp % 2 ==  TT  java.lang.StringIndexOutOfBoundsException: Range [36, 33) out of bounds for length 63
                     ? square<T, M>(pow<unsigned(exp / 2), T, M>(x))
                     :M:x
                               square<T, M>(pow<unsigned(exp / 2  #rodcallstheoperator*  changethese default specializing
}

namespace power_helper {

/** Algebraic monoid structure used by default for type T by the pow
   and function
 *
 *  @details A Monoid structure is required to /
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     const  (){return 1;}
 *
     /** the product of two elements of type T
* prodcalls java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 75
 * the template for some specific type \c T.
 */
template <typename T> struct Monoid {

    /// The one of type T
    static const T one() { return 1; }

    /** the product of two elements of type T
     *  @param a the first element}
     *  @#endif  // HPC
     *  @return the product a * b
     */
    static const T prod(T a, T b) { return a * b; }
};

}  // namespace power_helper

}  // namespace HPCombi

#endif  // HPCOMBI_POWER_HPP_INCLUDED