Function.hpp

Go to the documentation of this file.

// This file is part of GQCG-GQCP.
//
// Copyright (C) 2017-2020  the GQCG developers
//
// GQCG-GQCP is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GQCG-GQCP 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GQCG-GQCP.  If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
 
#include "Utilities/aliases.hpp"
#include "Utilities/type_traits.hpp"
 
#include <boost/format.hpp>
 
 
namespace GQCP {
 
 
/*
 *  MARK: Forward declarations
 */
template <typename OutputType, typename InputType>
class Function;
 
 
/*
 *  MARK: `FunctionProduct` implementation
 */
 
template <typename T1, typename T2 = T1>
class FunctionProduct:
    public Function<product_t<typename T1::OutputType, typename T2::OutputType>, typename T1::InputType> {
 
    static_assert(std::is_same<typename T1::InputType, typename T2::InputType>::value, "FunctionProduct: T1 and T2 should have the same InputType.");
 
private:
    // The left-hand side of the product.
    T1 m_lhs;
 
    // The right-hand side of the product.
    T2 m_rhs;
 
 
public:
    // The combined output type of the `operator()`.
    using OutputType = product_t<typename T1::OutputType, typename T2::OutputType>;
 
    // The input type of the `operator()`.
    using InputType = typename T1::InputType;  // Due to the `static_assert`, this is equal to `T2::InputType`.
 
 
public:
    /*
     *  MARK: Constructors
     */
 
    FunctionProduct(const T1& lhs, const T2& rhs) :
        m_lhs {lhs},
        m_rhs {rhs} {}
 
 
    FunctionProduct() = default;
 
 
    FunctionProduct(const int zero) :
        FunctionProduct() {
 
        if (zero != 0) {
            throw std::invalid_argument("FunctionProduct(const int): Can't convert a non-zero integer to a 'zero' instance.");
        }
    }
 
 
    /*
     *  MARK: General information
     */
 
    std::string description() const {
        return (boost::format("((%s) * (%s))") % this->m_lhs.description() % this->m_rhs.description()).str();
    }
 
 
    /*
     *  MARK: Access
     */
 
    const T1& lhs() const { return this->m_lhs; }
 
    const T2& rhs() const { return this->m_rhs; }
 
    OutputType operator()(const InputType& in) const override {
        return this->m_lhs(in) * this->m_rhs(in);
    }
};
 
 
/*
 *  MARK: `Function` implementation
 */
 
template <typename _OutputType, typename _InputType>
class Function {
public:
    // The return type of the `operator()`.
    using OutputType = _OutputType;
 
    // The input type of the `operator()`.
    using InputType = _InputType;
 
 
public:
    /*
     *  MARK: Destructor
     */
 
    virtual ~Function() = default;
 
 
    /*
     *  MARK: `Function` behavior
     */
 
    virtual OutputType operator()(const InputType& in) const = 0;
};
 
 
/*
 *  MARK: Aliases related to `Function`.
 */
 
template <typename T>
using IsFunction = enable_if_t<std::is_base_of<Function<typename T::OutputType, typename T::InputType>, T>::value>;
 
 
template <typename F1, typename F2, typename = IsFunction<F1>, typename = IsFunction<F2>>
FunctionProduct<F1, F2> operator*(const F1& lhs, const F2& rhs) {
 
    return FunctionProduct<F1, F2>(lhs, rhs);
}
 
 
}  // namespace GQCP