UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-01-19 00:37:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

[poincare] Float can be serialize

Browse Source
This commit is contained in:
Émilie Feral
2018-09-18 18:22:02 +02:00
parent cf8378434d
commit c02691a84b
5 changed files with 81 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
poincare/Makefile
View File

@@ -138,6 +138,7 @@ tests += $(addprefix poincare/test/,\
division.cpp\
expression.cpp\
factorial.cpp\
float.cpp\
fraction_layout.cpp\
function.cpp\
helper.cpp\

10
poincare/include/poincare/float.h
View File

@@ -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<float> approximate(SinglePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate<float>(context, angleUnit); }
Evaluation<double> approximate(DoublePrecision p, Context& context, Preferences::AngleUnit angleUnit) const override { return templatedApproximate<double>(context, angleUnit); }

13
poincare/src/float.cpp
View File

@@ -1,4 +1,5 @@
#include <poincare/float.h>
#include <poincare/layout_helper.h>
namespace Poincare {
@@ -23,6 +24,18 @@ int FloatNode<T>::simplificationOrderSameType(const ExpressionNode * e, bool can
return 0;
}
template<typename T>
int FloatNode<T>::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
return PrintFloat::convertFloatToText(m_value, buffer, bufferSize, numberOfSignificantDigits, floatDisplayMode);
}
template<typename T>
Layout FloatNode<T>::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<typename T>
Float<T>::Float(T value) : Number(TreePool::sharedPool()->createTreeNode<FloatNode<T>>()) {
node()->setFloat(value);

47
poincare/test/convert_expression_to_text.cpp
View File

@@ -56,13 +56,6 @@ void assert_expression_prints_to(Expression e, const char * result, Preferences:
delete[] taggedBuffer;
}
template<typename T>
void assert_approximation_prints_to(Float<T> e, const char * result) {
GlobalContext globalContext;
Expression approximation = e.template approximate<T>(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<double>(-1.23456789E30), "-1.23456789E30");
assert_approximation_prints_to(Float<double>(1.23456789E30), "1.23456789E30");
assert_approximation_prints_to(Float<double>(-1.23456789E-30), "-1.23456789E-30");
assert_approximation_prints_to(Float<double>(-1.2345E-3), "-0.0012345");
assert_approximation_prints_to(Float<double>(1.2345E-3), "0.0012345");
assert_approximation_prints_to(Float<double>(1.2345E3), "1234.5");
assert_approximation_prints_to(Float<double>(-1.2345E3), "-1234.5");
assert_approximation_prints_to(Float<double>(0.99999999999995), "9.9999999999995E-1");
assert_approximation_prints_to(Float<double>(0.00000099999999999995), "9.9999999999995E-7");
assert_approximation_prints_to(Float<double>(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7");
assert_approximation_prints_to(Float<float>(1.2345E-1), "0.12345");
assert_approximation_prints_to(Float<float>(1), "1");
assert_approximation_prints_to(Float<float>(0.9999999999999995), "1");
assert_approximation_prints_to(Float<float>(1.2345E6), "1234500");
assert_approximation_prints_to(Float<float>(-1.2345E6), "-1234500");
assert_approximation_prints_to(Float<float>(0.0000009999999999999995), "0.000001");
assert_approximation_prints_to(Float<float>(-1.2345E-1), "-0.12345");
assert_expression_prints_to(Float<double>(-1.23456789E30), "-1.23456789E30", DecimalMode, 14);
assert_expression_prints_to(Float<double>(1.23456789E30), "1.23456789E30", DecimalMode, 14);
assert_expression_prints_to(Float<double>(-1.23456789E-30), "-1.23456789E-30", DecimalMode, 14);
assert_expression_prints_to(Float<double>(-1.2345E-3), "-0.0012345", DecimalMode);
assert_expression_prints_to(Float<double>(1.2345E-3), "0.0012345", DecimalMode);
assert_expression_prints_to(Float<double>(1.2345E3), "1234.5", DecimalMode);
assert_expression_prints_to(Float<double>(-1.2345E3), "-1234.5", DecimalMode);
assert_expression_prints_to(Float<double>(0.99999999999995), "9.9999999999995E-1", DecimalMode, 14);
assert_expression_prints_to(Float<double>(0.00000099999999999995), "9.9999999999995E-7", DecimalMode, 14);
assert_expression_prints_to(Float<double>(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7", DecimalMode, 14);
assert_expression_prints_to(Float<float>(1.2345E-1), "0.12345", DecimalMode);
assert_expression_prints_to(Float<float>(1), "1", DecimalMode);
assert_expression_prints_to(Float<float>(0.9999999999999995), "1", DecimalMode);
assert_expression_prints_to(Float<float>(1.2345E6), "1234500", DecimalMode);
assert_expression_prints_to(Float<float>(-1.2345E6), "-1234500", DecimalMode);
assert_expression_prints_to(Float<float>(0.0000009999999999999995), "0.000001", DecimalMode);
assert_expression_prints_to(Float<float>(-1.2345E-1), "-0.12345", DecimalMode);
assert_approximation_prints_to<double>(Float<double>(INFINITY), "inf");
assert_approximation_prints_to<float>(Float<float>(0.0f), "0");
assert_approximation_prints_to<float>(Float<float>(NAN), "undef");
assert_expression_prints_to(Float<double>(INFINITY), "inf", DecimalMode);
assert_expression_prints_to(Float<float>(0.0f), "0", DecimalMode);
assert_expression_prints_to(Float<float>(NAN), "undef", DecimalMode);
}

45
poincare/test/float.cpp Normal file
View File

@@ -0,0 +1,45 @@
#include <quiz.h>
#include <poincare.h>
#include <string.h>
#include <ion.h>
#include <stdlib.h>
#include <assert.h>
#include <cmath>
#include "helper.h"
using namespace Poincare;
template<typename T>
void assert_float_evaluates_to(Float<T> f, const char * result) {
GlobalContext globalContext;
int numberOfDigits = sizeof(T) == sizeof(double) ? PrintFloat::k_numberOfStoredSignificantDigits : PrintFloat::k_numberOfPrintedSignificantDigits;
char buffer[500];
f.template approximate<T>(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<double>(Float<double>(-1.23456789E30), "-1.23456789E30");
assert_float_evaluates_to<double>(Float<double>(1.23456789E30), "1.23456789E30");
assert_float_evaluates_to<double>(Float<double>(-1.23456789E-30), "-1.23456789E-30");
assert_float_evaluates_to<double>(Float<double>(-1.2345E-3), "-0.0012345");
assert_float_evaluates_to<double>(Float<double>(1.2345E-3), "0.0012345");
assert_float_evaluates_to<double>(Float<double>(1.2345E3), "1234.5");
assert_float_evaluates_to<double>(Float<double>(-1.2345E3), "-1234.5");
assert_float_evaluates_to<double>(Float<double>(0.99999999999995), "9.9999999999995E-1");
assert_float_evaluates_to<double>(Float<double>(0.00000099999999999995), "9.9999999999995E-7");
assert_float_evaluates_to<double>(Float<double>(0.0000009999999999901200121020102010201201201021099995), "9.9999999999012E-7");
assert_float_evaluates_to<float>(Float<float>(1.2345E-1), "0.12345");
assert_float_evaluates_to<float>(Float<float>(1), "1");
assert_float_evaluates_to<float>(Float<float>(0.9999999999999995), "1");
assert_float_evaluates_to<float>(Float<float>(1.2345E6), "1234500");
assert_float_evaluates_to<float>(Float<float>(-1.2345E6), "-1234500");
assert_float_evaluates_to<float>(Float<float>(0.0000009999999999999995), "0.000001");
assert_float_evaluates_to<float>(Float<float>(-1.2345E-1), "-0.12345");
assert_float_evaluates_to<double>(Float<double>(INFINITY), "inf");
assert_float_evaluates_to<float>(Float<float>(0.0f), "0");
assert_float_evaluates_to<float>(Float<float>(NAN), "undef");
}