Remove unused ExpressionTypes - Remove TERNARY (replaced by function call) - Combine PARAMETER and RUNTIME_CONSTANT into INPUT_ASSIGNMENT Change-Id: Id35fb45da08a9f80c1ac0dab7008deb0b3922835
diff --git a/include/ceres/internal/expression.h b/include/ceres/internal/expression.h index 5ab2d62..b9e2e39 100644 --- a/include/ceres/internal/expression.h +++ b/include/ceres/internal/expression.h
@@ -183,15 +183,15 @@ // v_0 = 3.1415; COMPILE_TIME_CONSTANT, - // For example a local member of the cost-functor. + // Assignment from a user-variable to a generated variable that can be used by + // other expressions. This is used for local variables of cost functors and + // parameters of a functions. // v_0 = _observed_point_x; - RUNTIME_CONSTANT, + // v_0 = parameters[0][0]; + INPUT_ASSIGNMENT, - // Input parameter - // v_0 = parameters[1][5]; - PARAMETER, - - // Output Variable Assignemnt + // Assignment from a generated variable to a user-variable. Used to store the + // output of a generated cost functor. // residual[0] = v_51; OUTPUT_ASSIGNMENT, @@ -223,11 +223,6 @@ // v_5 = f(v_0,v_1,...) FUNCTION_CALL, - // The ternary ?-operator. Separated from the general function call for easier - // access. - // v_3 = ternary(v_0,v_1,v_2); - TERNARY, - // Conditional control expressions if/else/endif. // These are special expressions, because they don't define a new variable. IF, @@ -257,8 +252,7 @@ // These functions create the corresponding expression, add them to an // internal vector and return a reference to them. static ExpressionId CreateCompileTimeConstant(double v); - static ExpressionId CreateRuntimeConstant(const std::string& name); - static ExpressionId CreateParameter(const std::string& name); + static ExpressionId CreateInputAssignment(const std::string& name); static ExpressionId CreateOutputAssignment(ExpressionId v, const std::string& name); static ExpressionId CreateAssignment(ExpressionId dst, ExpressionId src); @@ -273,9 +267,6 @@ static ExpressionId CreateLogicalNegation(ExpressionId v); static ExpressionId CreateFunctionCall( const std::string& name, const std::vector<ExpressionId>& params); - static ExpressionId CreateTernary(ExpressionId condition, - ExpressionId if_true, - ExpressionId if_false); // Conditional control expressions are inserted into the graph but can't be // referenced by other expressions. Therefore they don't return an
diff --git a/include/ceres/internal/expression_ref.h b/include/ceres/internal/expression_ref.h index e0386f0..3d376ee 100644 --- a/include/ceres/internal/expression_ref.h +++ b/include/ceres/internal/expression_ref.h
@@ -56,6 +56,11 @@ // must work for T = Jet<ExpressionRef>. ExpressionRef(double compile_time_constant); + // By adding this constructor (which always throws an error) we can detect + // invalid usage of ExpressionRef. ExpressionRef can only be created from + // constexpr doubles. + ExpressionRef(double& test); + // Create an ASSIGNMENT expression from other to this. // // For example: @@ -182,21 +187,21 @@ // This struct is used to mark numbers which are constant over // multiple invocations but can differ between instances. template <typename T> -struct RuntimeConstant { +struct InputAssignment { using ReturnType = T; static inline ReturnType Get(double v, const char* /* unused */) { return v; } }; template <> -struct RuntimeConstant<ExpressionRef> { +struct InputAssignment<ExpressionRef> { using ReturnType = ExpressionRef; static inline ReturnType Get(double /* unused */, const char* name) { - return ExpressionRef::Create(Expression::CreateRuntimeConstant(name)); + return ExpressionRef::Create(Expression::CreateInputAssignment(name)); } }; template <typename G, int N> -struct RuntimeConstant<Jet<G, N>> { +struct InputAssignment<Jet<G, N>> { using ReturnType = Jet<G, N>; static inline Jet<G, N> Get(double v, const char* /* unused */) { return Jet<G, N>(v); @@ -204,27 +209,31 @@ }; template <int N> -struct RuntimeConstant<Jet<ExpressionRef, N>> { +struct InputAssignment<Jet<ExpressionRef, N>> { using ReturnType = Jet<ExpressionRef, N>; static inline ReturnType Get(double /* unused */, const char* name) { // Note: The scalar value of v will be thrown away, because we don't need it // during code generation. return Jet<ExpressionRef, N>( - ExpressionRef::Create(Expression::CreateRuntimeConstant(name))); + ExpressionRef::Create(Expression::CreateInputAssignment(name))); } }; template <typename T> -inline typename RuntimeConstant<T>::ReturnType MakeRuntimeConstant( +inline typename InputAssignment<T>::ReturnType MakeInputAssignment( double v, const char* name) { - return RuntimeConstant<T>::Get(v, name); + return InputAssignment<T>::Get(v, name); } -#define CERES_EXPRESSION_RUNTIME_CONSTANT(_v) \ - ceres::internal::MakeRuntimeConstant<T>(_v, #_v) +// This macro should be used for local variables in cost functors. Using local +// variables directly, will compile their current value into the code. +// Example: +// T x = CERES_LOCAL_VARIABLE(observed_x_); +#define CERES_LOCAL_VARIABLE(_v) \ + ceres::internal::MakeInputAssignment<T>(_v, #_v) inline ExpressionRef MakeParameter(const std::string& name) { - return ExpressionRef::Create(Expression::CreateParameter(name)); + return ExpressionRef::Create(Expression::CreateInputAssignment(name)); } inline ExpressionRef MakeOutput(ExpressionRef v, const std::string& name) { return ExpressionRef::Create(Expression::CreateOutputAssignment(v.id, name));
diff --git a/internal/ceres/expression.cc b/internal/ceres/expression.cc index 4c8dd5c..b3f9106 100644 --- a/internal/ceres/expression.cc +++ b/internal/ceres/expression.cc
@@ -63,33 +63,12 @@ return expr.lhs_id_; } -ExpressionId Expression::CreateRuntimeConstant(const std::string& name) { - auto& expr = MakeArithmeticExpression(ExpressionType::RUNTIME_CONSTANT); +ExpressionId Expression::CreateInputAssignment(const std::string& name) { + auto& expr = MakeArithmeticExpression(ExpressionType::INPUT_ASSIGNMENT); expr.name_ = name; return expr.lhs_id_; } -ExpressionId Expression::CreateParameter(const std::string& name) { - auto& expr = MakeArithmeticExpression(ExpressionType::PARAMETER); - expr.name_ = name; - return expr.lhs_id_; -} - -ExpressionId Expression::CreateAssignment(ExpressionId dst, ExpressionId src) { - auto& expr = MakeArithmeticExpression(ExpressionType::ASSIGNMENT, dst); - - expr.arguments_.push_back(src); - return expr.lhs_id_; -} - -ExpressionId Expression::CreateUnaryArithmetic(const std::string& op, - ExpressionId v) { - auto& expr = MakeArithmeticExpression(ExpressionType::UNARY_ARITHMETIC); - expr.name_ = op; - expr.arguments_.push_back(v); - return expr.lhs_id_; -} - ExpressionId Expression::CreateOutputAssignment(ExpressionId v, const std::string& name) { auto& expr = MakeArithmeticExpression(ExpressionType::OUTPUT_ASSIGNMENT); @@ -98,21 +77,28 @@ return expr.lhs_id_; } -ExpressionId Expression::CreateFunctionCall( - const std::string& name, const std::vector<ExpressionId>& params) { - auto& expr = MakeArithmeticExpression(ExpressionType::FUNCTION_CALL); - expr.arguments_ = params; - expr.name_ = name; +ExpressionId Expression::CreateAssignment(ExpressionId dst, ExpressionId src) { + auto& expr = MakeArithmeticExpression(ExpressionType::ASSIGNMENT, dst); + + expr.arguments_.push_back(src); return expr.lhs_id_; } -ExpressionId Expression::CreateTernary(ExpressionId condition, - ExpressionId if_true, - ExpressionId if_false) { - auto& expr = MakeArithmeticExpression(ExpressionType::TERNARY); - expr.arguments_.push_back(condition); - expr.arguments_.push_back(if_true); - expr.arguments_.push_back(if_false); +ExpressionId Expression::CreateBinaryArithmetic(const std::string& op, + ExpressionId l, + ExpressionId r) { + auto& expr = MakeArithmeticExpression(ExpressionType::BINARY_ARITHMETIC); + expr.name_ = op; + expr.arguments_.push_back(l); + expr.arguments_.push_back(r); + return expr.lhs_id_; +} + +ExpressionId Expression::CreateUnaryArithmetic(const std::string& op, + ExpressionId v) { + auto& expr = MakeArithmeticExpression(ExpressionType::UNARY_ARITHMETIC); + expr.name_ = op; + expr.arguments_.push_back(v); return expr.lhs_id_; } @@ -132,13 +118,11 @@ return expr.lhs_id_; } -ExpressionId Expression::CreateBinaryArithmetic(const std::string& op, - ExpressionId l, - ExpressionId r) { - auto& expr = MakeArithmeticExpression(ExpressionType::BINARY_ARITHMETIC); - expr.name_ = op; - expr.arguments_.push_back(l); - expr.arguments_.push_back(r); +ExpressionId Expression::CreateFunctionCall( + const std::string& name, const std::vector<ExpressionId>& params) { + auto& expr = MakeArithmeticExpression(ExpressionType::FUNCTION_CALL); + expr.arguments_ = params; + expr.name_ = name; return expr.lhs_id_; }
diff --git a/internal/ceres/expression_ref.cc b/internal/ceres/expression_ref.cc index 7c2bc5d..9aa25d4 100644 --- a/internal/ceres/expression_ref.cc +++ b/internal/ceres/expression_ref.cc
@@ -44,6 +44,11 @@ id = Expression::CreateCompileTimeConstant(compile_time_constant); } +ExpressionRef::ExpressionRef(double& test) { + CHECK(false) + << "ExpressionRefs can only be created from compile-time constants."; +} + ExpressionRef::ExpressionRef(const ExpressionRef& other) { *this = other; } ExpressionRef& ExpressionRef::operator=(const ExpressionRef& other) { @@ -125,7 +130,7 @@ ExpressionRef Ternary(ComparisonExpressionRef c, ExpressionRef a, ExpressionRef b) { - return ExpressionRef::Create(Expression::CreateTernary(c.id, a.id, b.id)); + return MakeFunctionCall("ternary", {c.id, a.id, b.id}); } #define CERES_DEFINE_EXPRESSION_COMPARISON_OPERATOR(op) \