replace.h

// This file is part of MARTY.
//
// MARTY 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 3 of the License, or
// (at your option) any later version.
//
// MARTY 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 MARTY. If not, see <https://www.gnu.org/licenses/>.

#pragma once

#include "abstract.h"
#include "index.h"

namespace csl {

// Expression replacements

void Replace(
        csl::Expr       &expr,
        csl::Expr const &from,
        csl::Expr const &to
        );

void Replace(
        csl::Expr         &expr,
        csl::Parent const &from,
        csl::Parent const &to
        );

void Replace(
        csl::Expr         &expr,
        csl::Parent const &from,
        csl::Expr   const &to
        );

void Replace(
        csl::Expr                      &expr,
        std::vector<csl::Parent> const &from,
        std::vector<csl::Parent> const &to
        );

void Replace(
        csl::Expr                    &expr,
        std::vector<csl::Expr> const &from,
        std::vector<csl::Expr> const &to
        );

void ReplaceIndicial(
        csl::Expr                    &expr,
        std::vector<csl::Expr> const &from,
        std::vector<csl::Expr> const &to
        );

void Replace(
        csl::Expr                      &expr,
        std::vector<csl::Parent> const &from,
        std::vector<csl::Expr>   const &to,
        bool                            refresh = true
        );

template<class T, class U, class Type, class Type2 = Type>
struct canDecay {
    static inline constexpr bool value = 
        std::is_convertible_v<std::decay_t<T>, Type>
        && std::is_convertible_v<std::decay_t<U>, Type2>;

};

template<class T, class U, class Type, class Type2 = Type>
inline constexpr bool canDecay_v = canDecay<T, U, Type, Type2>::value;

// Template non void Replaced instead of Replace
// All impossible overloads are defined explicitly to allow other templates 
// overloads to work. Sad that C++20 is too recent (concepts would have been
// much more relevant) than this solution with std::enable_if.
template<class T, class U, class ...Params,
        typename = std::enable_if_t<
                !csl::canDecay_v<T, U, csl::Index>
                && !csl::canDecay_v<T, U, csl::IndexStructure>
                && !csl::canDecay_v<T, U, std::vector<csl::Index>>
                >
        >
[[nodiscard]] 
csl::Expr Replaced(
        csl::Expr const &expr,
        T              &&p1,
        U              &&p2,
        Params         &&...params
        )
{
    csl::Expr cpy = expr;
    csl::Replace(
        cpy, 
        std::forward<T>(p1),
        std::forward<U>(p2),
        std::forward<Params>(params)...
        );
    return cpy;
}

// Index replacements

[[nodiscard]]
csl::Expr Replaced(
        csl::Expr  const &expr,
        csl::Index const &from,
        csl::Index const &to,
        bool              refresh = true
        );

inline void Replace(
        csl::Expr        &expr,
        csl::Index const &from,
        csl::Index const &to,
        bool              refresh = true
        ) 
{
    expr = csl::Replaced(expr, from, to, refresh);
}

[[nodiscard]] 
csl::Expr Replaced(
        csl::Expr               const &expr,
        std::vector<csl::Index> const &from,
        std::vector<csl::Index> const &to,
        bool                           refresh = true
        );

inline void Replace(
        csl::Expr                     &expr,
        std::vector<csl::Index> const &from,
        std::vector<csl::Index> const &to,
        bool                           refresh = true
        )
{
    expr = csl::Replaced(expr, from, to, refresh);
}

[[nodiscard]] 
csl::Expr Replaced(
        csl::Expr           const &expr,
        csl::IndexStructure const &from,
        csl::IndexStructure const &to,
        bool                       refresh = true
        );

inline void Replace(
        csl::Expr                 &expr,
        csl::IndexStructure const &from,
        csl::IndexStructure const &to,
        bool                       refresh = true
        )
{
    expr = csl::Replaced(expr, from, to, refresh);
}

// Abbreviation treatment

using replacementRule = 
    std::function<std::optional<csl::Expr>(csl::Expr const&, bool)>;

inline auto ruleToPredicate(replacementRule const &rule) {
    return [&rule](csl::Expr const &expr) -> bool {
        return bool(rule(expr, true));
    };
}

bool hasWeakDependency(
        csl::Expr const &expr,
        std::function<bool(csl::Expr const&)> const &predicate
        );

void applyThroughAbbreviations(
        csl::Expr &expr,
        replacementRule const &rule
        );

// Replacement rules

std::optional<csl::Expr> scalarReplacement(
        csl::Expr              const &expr,
        std::vector<csl::Expr> const &from,
        std::vector<csl::Expr> const &ccFrom,
        std::vector<csl::Expr> const &to,
        bool                          isPredicate
        );

std::optional<csl::Expr> indicialReplacement(
        csl::Expr                     const &expr,
        std::vector<csl::Expr>        const &from,
        std::vector<csl::Parent_info> const &parentFrom,
        std::vector<csl::Expr>        const &to,
        bool                                 isPredicate
        );

std::optional<csl::Expr> tensorReplacement(
        csl::Expr                const &expr,
        std::vector<csl::Parent> const &from,
        std::vector<csl::Parent> const &to,
        bool                            isPredicate
        );

std::optional<csl::Expr> tensorExpressionReplacement(
        csl::Expr                const &expr,
        std::vector<csl::Parent> const &from,
        std::vector<csl::Expr>   const &to,
        bool                            isPredicate
        );

// Helper functions for indicial replacements

void ResetDummyIndices(csl::Expr &expr);

void ApplyIndices(
        csl::Expr                 &expr,
        csl::IndexStructure const &structure
        );

void ApplyIndices(
        csl::Expr                 &expr,
        csl::IndexStructure const &from,
        csl::IndexStructure const &to
        );

void renameIndex(
        csl::Index                       &index,
        std::map<csl::Index, csl::Index> &mapping
        );

void RenameIndices(csl::Expr& expr);

csl::Expr RenamedIndices(csl::Expr const& expr);

void internal_RenameIndices(
        csl::Expr                        &expr,
        std::map<csl::Index, csl::Index> &mapping
        );

// Template helper overloads

template<class ParentType,
    typename = std::enable_if_t<std::is_convertible_v<ParentType, Parent>>
    >
inline void Replace(
        Expr& expr,
        std::vector<ParentType> const& t_from,
        std::vector<ParentType> const& t_to)
{
    std::vector<Parent> from(t_from.size());
    std::vector<Parent> to(t_to.size());
    for (size_t i = 0; i != from.size(); ++i)
        from[i] = t_from[i];
    for (size_t i = 0; i != to.size(); ++i)
        to[i] = t_to[i];
    Replace(expr, from, to);
}

template<class ParentType,
    typename = std::enable_if_t<std::is_convertible_v<ParentType, Parent>>
    >
inline void Replace(
        Expr& expr,
        std::vector<ParentType> const& t_from,
        std::vector<csl::Expr>  const& to)
{
    std::vector<Parent> from(t_from.size());
    for (size_t i = 0; i != from.size(); ++i)
        from[i] = t_from[i];
    Replace(expr, from, to);
}

// Functions that try a replacement and keep the
// result only if it is simpler than the initial
// expression

template<class ...Args>
Expr Tried(const Expr& expr, Args &&...args)
{
    Expr trial = Replaced(expr, std::forward<Args>(args)...);
    return (*trial < expr.get()) ? trial : expr;
}

template<class ...Args>
void Try(Expr& expr, Args &&...args)
{
    Expr trial = Replaced(expr, std::forward<Args>(args)...);
    if (trial < expr)
        expr = trial;
}

} // namespace csl