diff --git a/poincare/Makefile b/poincare/Makefile index e73262464..722cba3a4 100644 --- a/poincare/Makefile +++ b/poincare/Makefile @@ -138,6 +138,7 @@ tests += $(addprefix poincare/test/,\ division.cpp\ expression.cpp\ factorial.cpp\ + float.cpp\ fraction_layout.cpp\ function.cpp\ helper.cpp\ diff --git a/poincare/include/poincare/float.h b/poincare/include/poincare/float.h index 12f2a8055..892f7fe87 100644 --- a/poincare/include/poincare/float.h +++ b/poincare/include/poincare/float.h @@ -44,15 +44,9 @@ public: int simplificationOrderSameType(const ExpressionNode * e, bool canBeInterrupted) const override; // Layout - int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { - assert(false); - return 0; - } + int serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Layout */ - Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override { - assert(false); - return nullptr; - } + Layout createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const override; /* Evaluation */ Evaluation approximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } Evaluation approximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate(context, angleUnit); } diff --git a/poincare/src/float.cpp b/poincare/src/float.cpp index 150ccb502..0ac32507d 100644 --- a/poincare/src/float.cpp +++ b/poincare/src/float.cpp @@ -1,4 +1,5 @@ #include +#include namespace Poincare { @@ -23,6 +24,18 @@ int FloatNode::simplificationOrderSameType(const ExpressionNode * e, bool can return 0; } +template +int FloatNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { + return PrintFloat::convertFloatToText(m_value, buffer, bufferSize, numberOfSignificantDigits, floatDisplayMode); +} + +template +Layout FloatNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const { + char buffer[PrintFloat::k_maxFloatBufferLength]; + int numberOfChars = serialize(buffer, PrintFloat::k_maxFloatBufferLength, floatDisplayMode, numberOfSignificantDigits); + return LayoutHelper::String(buffer, numberOfChars); +} + template Float::Float(T value) : Number(TreePool::sharedPool()->createTreeNode>()) { node()->setFloat(value); diff --git a/poincare/test/convert_expression_to_text.cpp b/poincare/test/convert_expression_to_text.cpp index c59fae5b0..cdd865aa2 100644 --- a/poincare/test/convert_expression_to_text.cpp +++ b/poincare/test/convert_expression_to_text.cpp @@ -56,13 +56,6 @@ void assert_expression_prints_to(Expression e, const char * result, Preferences: delete[] taggedBuffer; } -template -void assert_approximation_prints_to(Float e, const char * result) { - GlobalContext globalContext; - Expression approximation = e.template approximate(globalContext, Radian, Cartesian); - assert_expression_prints_to(approximation, result, DecimalMode, (sizeof(T) == sizeof(float) ? 7 : 14)); -} - QUIZ_CASE(assert_float_prints_to) { /* We expect 7 significative numbers but do not display 0 */ assert_float_prints_to(123.456f, "1.23456E2"); @@ -173,26 +166,26 @@ QUIZ_CASE(poincare_decimal_to_text) { } QUIZ_CASE(poincare_approximation_to_text) { - assert_approximation_prints_to(Float(-1.23456789E30), "-1.23456789E30"); - assert_approximation_prints_to(Float(1.23456789E30), "1.23456789E30"); - assert_approximation_prints_to(Float(-1.23456789E-30), "-1.23456789E-30"); - assert_approximation_prints_to(Float(-1.2345E-3), "-0.0012345"); - assert_approximation_prints_to(Float(1.2345E-3), "0.0012345"); - assert_approximation_prints_to(Float(1.2345E3), "1234.5"); - assert_approximation_prints_to(Float(-1.2345E3), "-1234.5"); - assert_approximation_prints_to(Float(0.99999999999995), "9.9999999999995E-1"); - assert_approximation_prints_to(Float(0.00000099999999999995), "9.9999999999995E-7"); - assert_approximation_prints_to(Float(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7"); - assert_approximation_prints_to(Float(1.2345E-1), "0.12345"); - assert_approximation_prints_to(Float(1), "1"); - assert_approximation_prints_to(Float(0.9999999999999995), "1"); - assert_approximation_prints_to(Float(1.2345E6), "1234500"); - assert_approximation_prints_to(Float(-1.2345E6), "-1234500"); - assert_approximation_prints_to(Float(0.0000009999999999999995), "0.000001"); - assert_approximation_prints_to(Float(-1.2345E-1), "-0.12345"); + assert_expression_prints_to(Float(-1.23456789E30), "-1.23456789E30", DecimalMode, 14); + assert_expression_prints_to(Float(1.23456789E30), "1.23456789E30", DecimalMode, 14); + assert_expression_prints_to(Float(-1.23456789E-30), "-1.23456789E-30", DecimalMode, 14); + assert_expression_prints_to(Float(-1.2345E-3), "-0.0012345", DecimalMode); + assert_expression_prints_to(Float(1.2345E-3), "0.0012345", DecimalMode); + assert_expression_prints_to(Float(1.2345E3), "1234.5", DecimalMode); + assert_expression_prints_to(Float(-1.2345E3), "-1234.5", DecimalMode); + assert_expression_prints_to(Float(0.99999999999995), "9.9999999999995E-1", DecimalMode, 14); + assert_expression_prints_to(Float(0.00000099999999999995), "9.9999999999995E-7", DecimalMode, 14); + assert_expression_prints_to(Float(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7", DecimalMode, 14); + assert_expression_prints_to(Float(1.2345E-1), "0.12345", DecimalMode); + assert_expression_prints_to(Float(1), "1", DecimalMode); + assert_expression_prints_to(Float(0.9999999999999995), "1", DecimalMode); + assert_expression_prints_to(Float(1.2345E6), "1234500", DecimalMode); + assert_expression_prints_to(Float(-1.2345E6), "-1234500", DecimalMode); + assert_expression_prints_to(Float(0.0000009999999999999995), "0.000001", DecimalMode); + assert_expression_prints_to(Float(-1.2345E-1), "-0.12345", DecimalMode); - assert_approximation_prints_to(Float(INFINITY), "inf"); - assert_approximation_prints_to(Float(0.0f), "0"); - assert_approximation_prints_to(Float(NAN), "undef"); + assert_expression_prints_to(Float(INFINITY), "inf", DecimalMode); + assert_expression_prints_to(Float(0.0f), "0", DecimalMode); + assert_expression_prints_to(Float(NAN), "undef", DecimalMode); } diff --git a/poincare/test/float.cpp b/poincare/test/float.cpp new file mode 100644 index 000000000..0006ff82f --- /dev/null +++ b/poincare/test/float.cpp @@ -0,0 +1,45 @@ +#include +#include +#include +#include +#include +#include +#include +#include "helper.h" + +using namespace Poincare; + +template +void assert_float_evaluates_to(Float f, const char * result) { + GlobalContext globalContext; + int numberOfDigits = sizeof(T) == sizeof(double) ? PrintFloat::k_numberOfStoredSignificantDigits : PrintFloat::k_numberOfPrintedSignificantDigits; + char buffer[500]; + f.template approximate(globalContext, Radian, Cartesian).serialize(buffer, sizeof(buffer), DecimalMode, numberOfDigits); + translate_in_ASCII_chars(buffer); + quiz_assert(strcmp(buffer, result) == 0); +} + +QUIZ_CASE(poincare_float_evaluate) { + assert_float_evaluates_to(Float(-1.23456789E30), "-1.23456789E30"); + assert_float_evaluates_to(Float(1.23456789E30), "1.23456789E30"); + assert_float_evaluates_to(Float(-1.23456789E-30), "-1.23456789E-30"); + assert_float_evaluates_to(Float(-1.2345E-3), "-0.0012345"); + assert_float_evaluates_to(Float(1.2345E-3), "0.0012345"); + assert_float_evaluates_to(Float(1.2345E3), "1234.5"); + assert_float_evaluates_to(Float(-1.2345E3), "-1234.5"); + assert_float_evaluates_to(Float(0.99999999999995), "9.9999999999995E-1"); + assert_float_evaluates_to(Float(0.00000099999999999995), "9.9999999999995E-7"); + assert_float_evaluates_to(Float(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7"); + assert_float_evaluates_to(Float(1.2345E-1), "0.12345"); + assert_float_evaluates_to(Float(1), "1"); + assert_float_evaluates_to(Float(0.9999999999999995), "1"); + assert_float_evaluates_to(Float(1.2345E6), "1234500"); + assert_float_evaluates_to(Float(-1.2345E6), "-1234500"); + assert_float_evaluates_to(Float(0.0000009999999999999995), "0.000001"); + assert_float_evaluates_to(Float(-1.2345E-1), "-0.12345"); + + assert_float_evaluates_to(Float(INFINITY), "inf"); + assert_float_evaluates_to(Float(0.0f), "0"); + assert_float_evaluates_to(Float(NAN), "undef"); + +}