expression_evaluator.cpp

Go to the documentation of this file.

/*
 * Copyright 2026 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "func_sketch/expressions/expression_evaluator.h"
 
#include <type_traits>
#include <variant>
#include <vector>
 
#include "func_sketch/common_types.h"
 
namespace func_sketch::expressions {
 
void ExpressionEvaluator::operator()(
    const Expression& expression, Real parameter, Real& result) {
    const Number parameter_as_number = parameter;
    Number result_as_number;
    evaluate(expression, parameter_as_number, result_as_number);
    std::visit(
        [&result](const auto& value) {
            using ValueType = std::decay_t<decltype(value)>;
            if constexpr (std::is_same_v<ValueType, Complex>) {
                result = std::real(value);
            } else {
                result = static_cast<Real>(value);
            }
        },
        result_as_number);
}
 
void ExpressionEvaluator::evaluate(
    const Expression& expression, Number parameter, Number& result) {
    std::visit([&parameter, &result](
                   const auto& expr) { evaluate(expr, parameter, result); },
        expression.as_variant());
}
 
void ExpressionEvaluator::evaluate(const ConstantExpression& expression,
    Number /*parameter*/, Number& result) {
    result = expression.value;
}
 
void ExpressionEvaluator::evaluate(const ParameterExpression& /*expression*/,
    Number parameter, Number& result) {
    result = parameter;
}
 
void ExpressionEvaluator::evaluate(
    const UnaryExpression& expression, Number parameter, Number& result) {
    Number target_value;
    evaluate(*expression.target, parameter, target_value);
    expression.operator_object(target_value, result);
}
 
void ExpressionEvaluator::evaluate(
    const BinaryExpression& expression, Number parameter, Number& result) {
    Number left_value;
    evaluate(*expression.left, parameter, left_value);
    Number right_value;
    evaluate(*expression.right, parameter, right_value);
    expression.operator_object(left_value, right_value, result);
}
 
void ExpressionEvaluator::evaluate(const FunctionCallExpression& expression,
    Number parameter, Number& result) {
    std::vector<Number> argument_values;
    argument_values.reserve(expression.arguments.size());
    for (const auto& argument : expression.arguments) {
        Number argument_value;
        evaluate(*argument, parameter, argument_value);
        argument_values.push_back(argument_value);
    }
    expression.function(argument_values, result);
}
 
}  // namespace func_sketch::expressions