saberbud/ceres-solver
1
0
Fork 0
mirror of https://github.com/ceres-solver/ceres-solver.git synced 2026-08-29 08:34:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix ExpressionRef

Browse Source 
- Add missing copy constructor
- Add make functions for input/output expressions
- Add missing ExpressionRef overload for MakeRuntimeConstant
- Add ExpressionRef overloads for common functions (cos,exp,...)
- Make ExpressionRef constructor from double implicit
- Add simple test for using ExpressionRef in Jets.
- Rename expression test macro

Change-Id: I071dc6717e4034a281662021998a91e80636da27
This commit is contained in:
Darius Rueckert
2019-11-13 18:33:06 +01:00
parent 6ba8c57d28
commit 7d0d69a4df
5 changed files with 148 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/ceres/internal/expression_ref.h
+65 -8
View File
@@ -50,7 +50,11 @@ struct ExpressionRef {
// Create a compile time constant expression directly from a double value.
// This is important so that we can write T(3.14) in our code and
// it's automatically converted to the correct expression.
explicit ExpressionRef(double compile_time_constant);
//
// This constructor is implicit, because the line
// T a(0);
// must work for T = Jet<ExpressionRef>.
ExpressionRef(double compile_time_constant);
// Create an ASSIGNMENT expression from other to this.
//
@@ -71,6 +75,7 @@ struct ExpressionRef {
//
// If 'other' is not pointing to a variable (id==invalid), we found an
// uninitialized assignment, which is handled as an error.
ExpressionRef(const ExpressionRef& other);
ExpressionRef& operator=(const ExpressionRef& other);
// Compound operators
@@ -96,8 +101,45 @@ ExpressionRef operator*(ExpressionRef x, ExpressionRef y);
ExpressionRef operator/(ExpressionRef x, ExpressionRef y);
// Functions
// TODO: Add all function supported by Jet.
ExpressionRef sin(ExpressionRef x);
// Helper function to create a function call expression.
// Users can generate code for their own custom functions by adding an overload
// for ExpressionRef that maps to MakeFunctionCall. See below for examples.
ExpressionRef MakeFunctionCall(const std::string& name,
const std::vector<ExpressionRef>& params);
#define CERES_DEFINE_UNARY_FUNCTION_CALL(name) \
inline ExpressionRef name(ExpressionRef x) { \
return MakeFunctionCall(#name, {x}); \
}
#define CERES_DEFINE_BINARY_FUNCTION_CALL(name) \
inline ExpressionRef name(ExpressionRef x, ExpressionRef y) { \
return MakeFunctionCall(#name, {x, y}); \
}
CERES_DEFINE_UNARY_FUNCTION_CALL(abs);
CERES_DEFINE_UNARY_FUNCTION_CALL(acos);
CERES_DEFINE_UNARY_FUNCTION_CALL(asin);
CERES_DEFINE_UNARY_FUNCTION_CALL(atan);
CERES_DEFINE_UNARY_FUNCTION_CALL(cbrt);
CERES_DEFINE_UNARY_FUNCTION_CALL(ceil);
CERES_DEFINE_UNARY_FUNCTION_CALL(cos);
CERES_DEFINE_UNARY_FUNCTION_CALL(cosh);
CERES_DEFINE_UNARY_FUNCTION_CALL(exp);
CERES_DEFINE_UNARY_FUNCTION_CALL(exp2);
CERES_DEFINE_UNARY_FUNCTION_CALL(floor);
CERES_DEFINE_UNARY_FUNCTION_CALL(log);
CERES_DEFINE_UNARY_FUNCTION_CALL(log2);
CERES_DEFINE_UNARY_FUNCTION_CALL(sin);
CERES_DEFINE_UNARY_FUNCTION_CALL(sinh);
CERES_DEFINE_UNARY_FUNCTION_CALL(sqrt);
CERES_DEFINE_UNARY_FUNCTION_CALL(tan);
CERES_DEFINE_UNARY_FUNCTION_CALL(tanh);
CERES_DEFINE_BINARY_FUNCTION_CALL(atan2);
CERES_DEFINE_BINARY_FUNCTION_CALL(pow);
#undef CERES_DEFINE_UNARY_FUNCTION_CALL
#undef CERES_DEFINE_BINARY_FUNCTION_CALL
// This additonal type is required, so that we can detect invalid conditions
// during compile time. For example, the following should create a compile time
@@ -142,13 +184,21 @@ ComparisonExpressionRef operator!(ComparisonExpressionRef a);
template <typename T>
struct RuntimeConstant {
using ReturnType = T;
static inline ReturnType Get(double v, const char* name) { return v; }
static inline ReturnType Get(double v, const char* /* unused */) { return v; }
};
template <>
struct RuntimeConstant<ExpressionRef> {
using ReturnType = ExpressionRef;
static inline ReturnType Get(double /* unused */, const char* name) {
return ExpressionRef::Create(Expression::CreateRuntimeConstant(name));
}
};
template <typename G, int N>
struct RuntimeConstant<Jet<G, N>> {
using ReturnType = Jet<G, N>;
static inline Jet<G, N> Get(double v, const char* name) {
static inline Jet<G, N> Get(double v, const char* /* unused */) {
return Jet<G, N>(v);
}
};
@@ -156,11 +206,11 @@ struct RuntimeConstant<Jet<G, N>> {
template <int N>
struct RuntimeConstant<Jet<ExpressionRef, N>> {
using ReturnType = Jet<ExpressionRef, N>;
static inline ReturnType Get(double v, const char* name) {
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.
(void)v;
return Jet<ExpressionRef, N>(Expression::CreateRuntimeConstant(name));
return Jet<ExpressionRef, N>(
ExpressionRef::Create(Expression::CreateRuntimeConstant(name)));
}
};
@@ -173,6 +223,13 @@ inline typename RuntimeConstant<T>::ReturnType MakeRuntimeConstant(
#define CERES_EXPRESSION_RUNTIME_CONSTANT(_v) \
ceres::internal::MakeRuntimeConstant<T>(_v, #_v)
inline ExpressionRef MakeParameter(const std::string& name) {
return ExpressionRef::Create(Expression::CreateParameter(name));
}
inline ExpressionRef MakeOutput(ExpressionRef v, const std::string& name) {
return ExpressionRef::Create(Expression::CreateOutputAssignment(v.id, name));
}
// The CERES_CODEGEN macro is defined by the build system only during code
// generation. In all other cases the CERES_IF/ELSE macros just expand to the
// if/else keywords.
internal/ceres/conditional_expressions_test.cc
+21 -21
View File
@@ -55,7 +55,7 @@ TEST(Expression, AssignmentElimination) {
// clang-format off
// Id Type Lhs Value Name Arguments
TE(0, COMPILE_TIME_CONSTANT, 0, 2, "");
CHECK_EXPRESSION(0, COMPILE_TIME_CONSTANT, 0, 2, "",);
// clang-format on
// Variables after execution:
@@ -86,9 +86,9 @@ TEST(Expression, Assignment) {
// clang-format off
// Id, Type, Lhs, Value, Name, Arguments
TE( 0, COMPILE_TIME_CONSTANT, 0, 2, "", );
TE( 1, COMPILE_TIME_CONSTANT, 1, 4, "", );
TE( 2, ASSIGNMENT, 1, 0, "", 0);
CHECK_EXPRESSION( 0, COMPILE_TIME_CONSTANT, 0, 2, "", );
CHECK_EXPRESSION( 1, COMPILE_TIME_CONSTANT, 1, 4, "", );
CHECK_EXPRESSION( 2, ASSIGNMENT, 1, 0, "", 0);
// clang-format on
// Variables after execution:
@@ -123,12 +123,12 @@ TEST(Expression, ConditionalMinimal) {
// clang-format off
// Id, Type, Lhs, Value, Name, Arguments...
TE( 0, COMPILE_TIME_CONSTANT, 0, 2, "", );
TE( 1, COMPILE_TIME_CONSTANT, 1, 3, "", );
TE( 2, BINARY_COMPARISON, 2, 0, "<", 0, 1);
TE( 3, IF, -1, 0, "", 2);
TE( 4, ELSE, -1, 0, "", );
TE( 5, ENDIF, -1, 0, "", );
CHECK_EXPRESSION( 0, COMPILE_TIME_CONSTANT, 0, 2, "", );
CHECK_EXPRESSION( 1, COMPILE_TIME_CONSTANT, 1, 3, "", );
CHECK_EXPRESSION( 2, BINARY_COMPARISON, 2, 0, "<", 0, 1);
CHECK_EXPRESSION( 3, IF, -1, 0, "", 2);
CHECK_EXPRESSION( 4, ELSE, -1, 0, "", );
CHECK_EXPRESSION( 5, ENDIF, -1, 0, "", );
// clang-format on
}
@@ -162,17 +162,17 @@ TEST(Expression, ConditionalAssignment) {
// clang-format off
// Id, Type, Lhs, Value, Name, Arguments...
TE( 0, COMPILE_TIME_CONSTANT, 0, 2, "", );
TE( 1, COMPILE_TIME_CONSTANT, 1, 3, "", );
TE( 2, BINARY_COMPARISON, 2, 0, "<", 0, 1);
TE( 3, IF, -1, 0, "", 2);
TE( 4, BINARY_ARITHMETIC, 4, 0, "+", 0, 1);
TE( 5, ELSE, -1, 0, "", );
TE( 6, BINARY_ARITHMETIC, 6, 0, "-", 0, 1);
TE( 7, ASSIGNMENT, 4, 0, "", 6 );
TE( 8, ENDIF, -1, 0, "", );
TE( 9, BINARY_ARITHMETIC, 9, 0, "+", 4, 0);
TE( 10, ASSIGNMENT, 4, 0, "", 9 );
CHECK_EXPRESSION( 0, COMPILE_TIME_CONSTANT, 0, 2, "", );
CHECK_EXPRESSION( 1, COMPILE_TIME_CONSTANT, 1, 3, "", );
CHECK_EXPRESSION( 2, BINARY_COMPARISON, 2, 0, "<", 0, 1);
CHECK_EXPRESSION( 3, IF, -1, 0, "", 2);
CHECK_EXPRESSION( 4, BINARY_ARITHMETIC, 4, 0, "+", 0, 1);
CHECK_EXPRESSION( 5, ELSE, -1, 0, "", );
CHECK_EXPRESSION( 6, BINARY_ARITHMETIC, 6, 0, "-", 0, 1);
CHECK_EXPRESSION( 7, ASSIGNMENT, 4, 0, "", 6 );
CHECK_EXPRESSION( 8, ENDIF, -1, 0, "", );
CHECK_EXPRESSION( 9, BINARY_ARITHMETIC, 9, 0, "+", 4, 0);
CHECK_EXPRESSION( 10, ASSIGNMENT, 4, 0, "", 9 );
// clang-format on
// Variables after execution:
internal/ceres/expression_ref.cc
+9 -2
View File
@@ -44,6 +44,8 @@ ExpressionRef::ExpressionRef(double compile_time_constant) {
id = Expression::CreateCompileTimeConstant(compile_time_constant);
}
ExpressionRef::ExpressionRef(const ExpressionRef& other) { *this = other; }
ExpressionRef& ExpressionRef::operator=(const ExpressionRef& other) {
// Assigning an uninitialized variable to another variable is an error.
CHECK(other.IsInitialized()) << "Uninitialized Assignment.";
@@ -111,8 +113,13 @@ ExpressionRef operator*(ExpressionRef x, ExpressionRef y) {
}
// Functions
ExpressionRef sin(ExpressionRef x) {
return ExpressionRef::Create(Expression::CreateFunctionCall("sin", {x.id}));
ExpressionRef MakeFunctionCall(const std::string& name,
const std::vector<ExpressionRef>& params) {
std::vector<ExpressionId> ids;
for (auto p : params) {
ids.push_back(p.id);
}
return ExpressionRef::Create(Expression::CreateFunctionCall(name, ids));
}
ExpressionRef Ternary(ComparisonExpressionRef c,
internal/ceres/expression_test.cc
+47 -4
View File
@@ -31,10 +31,8 @@
#define CERES_CODEGEN
#include "ceres/internal/expression_graph.h"
#include "ceres/internal/expression_ref.h"
#include "gtest/gtest.h"
#include "ceres/expression_test.h"
#include "ceres/jet.h"
namespace ceres {
namespace internal {
@@ -115,6 +113,51 @@ TEST(Expression, DirectlyDependsOn) {
ASSERT_TRUE(graph.ExpressionForId(d.id).DirectlyDependsOn(c.id));
}
TEST(Expression, Jet) {
using T = Jet<ExpressionRef, 1>;
StartRecordingExpressions();
T a(2, 0);
T b = a * a;
auto graph = StopRecordingExpressions();
// b is valid during the assignment so we expect an
// additional assignment expression.
EXPECT_EQ(graph.Size(), 8);
// Expected code
// v_0 = 2;
// v_1 = 0;
// v_2 = 1;
// v_1 = v_2;
// v_3 = v_0 * v_0;
// v_4 = v_0 * v_1;
// v_5 = v_1 * v_0;
// v_6 = v_3 * v_4;
// v_7 = v_5 * v_6;
// clang-format off
// Id, Type, Lhs, Value, Name, Arguments
CHECK_EXPRESSION( 0, COMPILE_TIME_CONSTANT, 0, 2, "", );
CHECK_EXPRESSION( 1, COMPILE_TIME_CONSTANT, 1, 0, "", );
CHECK_EXPRESSION( 2, COMPILE_TIME_CONSTANT, 2, 1, "", );
CHECK_EXPRESSION( 3, ASSIGNMENT, 1, 0, "", 2 );
CHECK_EXPRESSION( 4, BINARY_ARITHMETIC, 4, 0, "*", 0, 0);
CHECK_EXPRESSION( 5, BINARY_ARITHMETIC, 5, 0, "*", 0, 1);
CHECK_EXPRESSION( 6, BINARY_ARITHMETIC, 6, 0, "*", 1, 0);
CHECK_EXPRESSION( 7, BINARY_ARITHMETIC, 7, 0, "+", 5, 6);
// clang-format on
// Variables after execution:
//
// b.a <=> v_4
// b.v[0] <=> v_7
EXPECT_EQ(b.a.id, 4);
EXPECT_EQ(b.v[0].id, 7);
}
// Todo: remaining functions of Expression
} // namespace internal
internal/ceres/expression_test.h
+6 -6
View File
@@ -55,12 +55,12 @@ inline void TestExpression(const Expression& expr,
EXPECT_EQ(expr.arguments(), arguments);
}
#define TE(_id, _type, _lhs_id, _value, _name, ...) \
TestExpression(graph.ExpressionForId(_id), \
ExpressionType::_type, \
_lhs_id, \
_value, \
_name, \
#define CHECK_EXPRESSION(_id, _type, _lhs_id, _value, _name, ...) \
TestExpression(graph.ExpressionForId(_id), \
ExpressionType::_type, \
_lhs_id, \
_value, \
_name, \
{__VA_ARGS__})
} // namespace internal