Skip to content
Snippets Groups Projects
Commit 1dc79eaf authored by Stéphane Del Pino's avatar Stéphane Del Pino
Browse files

Provide sin function to the math module

`sin` is now functional, but it is hard coded, it is just some kind of proof of
concept.
parent 03e27112
No related branches found
No related tags found
1 merge request!37Feature/language
...@@ -6,18 +6,22 @@ ...@@ -6,18 +6,22 @@
#include <node_processor/CFunctionProcessor.hpp> #include <node_processor/CFunctionProcessor.hpp>
PUGS_INLINE std::unique_ptr<INodeProcessor> PUGS_INLINE std::unique_ptr<INodeProcessor>
ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node) ASTNodeCFunctionExpressionBuilder::_getArgumentProcessor(ASTNode& argument_node, ASTNodeDataVariant& argument_value)
{ {
#warning use correct types #warning use correct types
return std::make_unique<CFunctionArgumentProcessor<double, double>>(argument_node); return std::make_unique<CFunctionArgumentProcessor<double, double>>(argument_node, argument_value);
} }
PUGS_INLINE PUGS_INLINE
void void
ASTNodeCFunctionExpressionBuilder::_storeArgumentProcessor(ASTNode& argument_node, ASTNodeCFunctionExpressionBuilder::_storeArgumentProcessor(const size_t argument_number,
ASTNode& argument_node,
CFunctionProcessor& c_function_processor) CFunctionProcessor& c_function_processor)
{ {
c_function_processor.addArgumentProcessor(this->_getArgumentProcessor(argument_node)); auto& argument_values = c_function_processor.argumentValues();
c_function_processor.addArgumentProcessor(
this->_getArgumentProcessor(argument_node, argument_values[argument_number]));
} }
PUGS_INLINE PUGS_INLINE
...@@ -28,6 +32,8 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node, CFunc ...@@ -28,6 +32,8 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node, CFunc
const size_t arguments_number = argument_nodes.is<language::expression_list>() ? argument_nodes.children.size() : 1; const size_t arguments_number = argument_nodes.is<language::expression_list>() ? argument_nodes.children.size() : 1;
c_function_processor.setNumberOfArguments(arguments_number);
#warning use the correct number of parameters_domain_node #warning use the correct number of parameters_domain_node
const size_t parameters_number = 1; const size_t parameters_number = 1;
...@@ -41,10 +47,10 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node, CFunc ...@@ -41,10 +47,10 @@ ASTNodeCFunctionExpressionBuilder::_buildArgumentProcessors(ASTNode& node, CFunc
if (arguments_number > 1) { if (arguments_number > 1) {
for (size_t i = 0; i < arguments_number; ++i) { for (size_t i = 0; i < arguments_number; ++i) {
ASTNode& argument_node = *argument_nodes.children[i]; ASTNode& argument_node = *argument_nodes.children[i];
this->_storeArgumentProcessor(argument_node, c_function_processor); this->_storeArgumentProcessor(i, argument_node, c_function_processor);
} }
} else { } else {
this->_storeArgumentProcessor(argument_nodes, c_function_processor); this->_storeArgumentProcessor(0, argument_nodes, c_function_processor);
} }
} }
...@@ -61,6 +67,9 @@ ASTNodeCFunctionExpressionBuilder::ASTNodeCFunctionExpressionBuilder(ASTNode& no ...@@ -61,6 +67,9 @@ ASTNodeCFunctionExpressionBuilder::ASTNodeCFunctionExpressionBuilder(ASTNode& no
this->_buildArgumentProcessors(node, *c_function_processor); this->_buildArgumentProcessors(node, *c_function_processor);
c_function_processor->setFunctionExpressionProcessor(
std::make_unique<CFunctionExpressionProcessor<double, double>>(node, c_function_processor->argumentValues()));
ASTNodeDataType c_function_return_type = ASTNodeDataType::double_t; ASTNodeDataType c_function_return_type = ASTNodeDataType::double_t;
node.m_node_processor = std::move(c_function_processor); node.m_node_processor = std::move(c_function_processor);
......
...@@ -8,10 +8,13 @@ class CFunctionProcessor; ...@@ -8,10 +8,13 @@ class CFunctionProcessor;
class ASTNodeCFunctionExpressionBuilder class ASTNodeCFunctionExpressionBuilder
{ {
PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(ASTNode& argument_node); PUGS_INLINE std::unique_ptr<INodeProcessor> _getArgumentProcessor(ASTNode& argument_node,
ASTNodeDataVariant& argument_value);
PUGS_INLINE PUGS_INLINE
void _storeArgumentProcessor(ASTNode& argument_node, CFunctionProcessor& c_function_processor); void _storeArgumentProcessor(const size_t argument_number,
ASTNode& argument_node,
CFunctionProcessor& c_function_processor);
PUGS_INLINE PUGS_INLINE
void _buildArgumentProcessors(ASTNode& node, CFunctionProcessor& c_function_processor); void _buildArgumentProcessors(ASTNode& node, CFunctionProcessor& c_function_processor);
......
...@@ -5,11 +5,14 @@ ...@@ -5,11 +5,14 @@
#include <node_processor/INodeProcessor.hpp> #include <node_processor/INodeProcessor.hpp>
#include <cmath>
template <typename ProvidedValueType, typename ExpectedValueType> template <typename ProvidedValueType, typename ExpectedValueType>
class CFunctionArgumentProcessor final : public INodeProcessor class CFunctionArgumentProcessor final : public INodeProcessor
{ {
private: private:
ASTNode& m_provided_value_node; ASTNode& m_provided_value_node;
ASTNodeDataVariant& m_argument_value;
public: public:
void void
...@@ -17,14 +20,16 @@ class CFunctionArgumentProcessor final : public INodeProcessor ...@@ -17,14 +20,16 @@ class CFunctionArgumentProcessor final : public INodeProcessor
{ {
m_provided_value_node.execute(exec_policy); m_provided_value_node.execute(exec_policy);
// if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) { if constexpr (std::is_same_v<ExpectedValueType, ProvidedValueType>) {
// m_symbol_value = m_provided_value_node.m_value; m_argument_value = m_provided_value_node.m_value;
// } else { } else {
// m_symbol_value = static_cast<ExpectedValueType>(std::get<ProvidedValueType>(m_provided_value_node.m_value)); m_argument_value = static_cast<ExpectedValueType>(std::get<ProvidedValueType>(m_provided_value_node.m_value));
// } }
} }
CFunctionArgumentProcessor(ASTNode& provided_value_node) : m_provided_value_node{provided_value_node} {} CFunctionArgumentProcessor(ASTNode& provided_value_node, ASTNodeDataVariant& argument_value)
: m_provided_value_node{provided_value_node}, m_argument_value{argument_value}
{}
}; };
template <typename ReturnType, typename ExpressionValueType> template <typename ReturnType, typename ExpressionValueType>
...@@ -33,42 +38,83 @@ class CFunctionExpressionProcessor final : public INodeProcessor ...@@ -33,42 +38,83 @@ class CFunctionExpressionProcessor final : public INodeProcessor
private: private:
ASTNode& m_node; ASTNode& m_node;
std::vector<ASTNodeDataVariant>& m_argument_values;
public: public:
void void
execute(ExecUntilBreakOrContinue& exec_policy) execute(ExecUntilBreakOrContinue& exec_policy)
{ {
// if constexpr (std::is_same_v<ReturnType, ExpressionValueType>) { if constexpr (std::is_same_v<ReturnType, ExpressionValueType>) {
// m_node.m_value = m_function_expression.m_value; std::visit(
// } else { [&](auto v) {
// m_node.m_value = static_cast<ReturnType>(std::get<ExpressionValueType>(m_function_expression.m_value)); if constexpr (std::is_arithmetic_v<decltype(v)>) {
// } m_node.m_value = std::sin(v);
} else {
throw parse_error("invalid C function evaluation", m_node.begin());
}
},
m_argument_values[0]);
} else {
std::visit(
[&](auto v) {
if constexpr (std::is_arithmetic_v<decltype(v)>) {
m_node.m_value = static_cast<ReturnType>(std::sin(v));
} else {
throw parse_error("invalid C function evaluation", m_node.begin());
}
},
m_argument_values[0]);
}
} }
CFunctionExpressionProcessor(ASTNode& node) : m_node{node} {} CFunctionExpressionProcessor(ASTNode& node, std::vector<ASTNodeDataVariant>& argument_values)
: m_node{node}, m_argument_values{argument_values}
{}
}; };
class CFunctionProcessor : public INodeProcessor class CFunctionProcessor : public INodeProcessor
{ {
private: private:
std::unique_ptr<INodeProcessor> m_function_expression_processor;
std::vector<std::unique_ptr<INodeProcessor>> m_argument_processors; std::vector<std::unique_ptr<INodeProcessor>> m_argument_processors;
std::vector<ASTNodeDataVariant> m_argument_values;
public: public:
void
setNumberOfArguments(const size_t& number_of_arguments)
{
Assert(m_argument_values.size() == 0, "argument number has already been provided");
m_argument_values.resize(number_of_arguments);
}
std::vector<ASTNodeDataVariant>&
argumentValues()
{
return m_argument_values;
}
void void
addArgumentProcessor(std::unique_ptr<INodeProcessor>&& argument_processor) addArgumentProcessor(std::unique_ptr<INodeProcessor>&& argument_processor)
{ {
m_argument_processors.emplace_back(std::move(argument_processor)); m_argument_processors.emplace_back(std::move(argument_processor));
} }
void
setFunctionExpressionProcessor(std::unique_ptr<INodeProcessor>&& function_processor)
{
m_function_expression_processor = std::move(function_processor);
}
void void
execute(ExecUntilBreakOrContinue& exec_policy) execute(ExecUntilBreakOrContinue& exec_policy)
{ {
Assert(m_argument_processors.size() == m_argument_values.size());
for (auto& argument_processor : m_argument_processors) { for (auto& argument_processor : m_argument_processors) {
argument_processor->execute(exec_policy); argument_processor->execute(exec_policy);
} }
std::cerr << __FILE__ << ':' << __LINE__ << ": " << rang::fgB::red m_function_expression_processor->execute(exec_policy);
<< "execution of CFunctionProcessor not finished!" << rang::style::reset << '\n';
std::exit(1);
} }
CFunctionProcessor() = default; CFunctionProcessor() = default;
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment