UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-03-18 21:30:38 +01:00
Code Issues Packages Projects Releases Wiki Activity

[poincare] Use a Tuple instead of an ArrayBuilder for expression

Browse Source 
The Tuple is simply an initializer_list along with a convenience method
to cast between a list of TreeHandle and a list of Expression
This commit is contained in:
Romain Goyet
2020-04-09 17:55:14 -04:00
committed by Ecco
parent 1bd6105a0a
commit 807dd73e7b
92 changed files with 461 additions and 502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
apps/regression/model/cubic_model.cpp
View File

@@ -19,31 +19,29 @@ namespace Regression {
Layout CubicModel::layout() {
if (m_layout.isUninitialized()) {
constexpr int size = 15;
Layout layoutChildren[size] = {
m_layout = HorizontalLayout::Builder({
CodePointLayout::Builder('a', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
VerticalOffsetLayout::Builder(
CodePointLayout::Builder('3', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('3', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('b', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
VerticalOffsetLayout::Builder(
CodePointLayout::Builder('2', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('2', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('c', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('d', k_layoutFont),
};
m_layout = HorizontalLayout::Builder(layoutChildren, size);
});
}
return m_layout;
}
@@ -82,25 +80,28 @@ Expression CubicModel::expression(double * modelCoefficients) {
double b = modelCoefficients[1];
double c = modelCoefficients[2];
double d = modelCoefficients[3];
Expression addChildren[] = {
Multiplication::Builder(
// a*x^3+b*x^2+c*x+d
return Addition::Builder({
Multiplication::Builder({
Number::DecimalNumber(a),
Power::Builder(
Symbol::Builder('x'),
Decimal::Builder(3.0))),
Multiplication::Builder(
Decimal::Builder(3.0)
)
}),
Multiplication::Builder({
Number::DecimalNumber(b),
Power::Builder(
Symbol::Builder('x'),
Decimal::Builder(2.0))),
Multiplication::Builder(
Decimal::Builder(2.0)
)
}),
Multiplication::Builder({
Number::DecimalNumber(c),
Symbol::Builder('x')),
Symbol::Builder('x')
}),
Number::DecimalNumber(d)
};
// a*x^3+b*x^2+c*x+d
Expression result = Addition::Builder(addChildren, 4);
return result;
});
}
}

20
apps/regression/model/exponential_model.cpp
View File

@@ -13,21 +13,19 @@ namespace Regression {
Layout ExponentialModel::layout() {
if (m_layout.isUninitialized()) {
constexpr int size = 4;
Layout layoutChildren[size] = {
m_layout = HorizontalLayout::Builder({
CodePointLayout::Builder('a', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('e', k_layoutFont),
VerticalOffsetLayout::Builder(
HorizontalLayout::Builder(
CodePointLayout::Builder('b', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont)
),
VerticalOffsetLayoutNode::Position::Superscript
)
};
m_layout = HorizontalLayout::Builder(layoutChildren, size);
HorizontalLayout::Builder({
CodePointLayout::Builder('b', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont)
}),
VerticalOffsetLayoutNode::Position::Superscript
)
});
}
return m_layout;
}

38
apps/regression/model/logistic_model.cpp
View File

@@ -13,29 +13,25 @@ namespace Regression {
Layout LogisticModel::layout() {
if (m_layout.isUninitialized()) {
constexpr int exponentSize = 4;
Layout exponentLayoutChildren[exponentSize] = {
CodePointLayout::Builder('-', k_layoutFont),
CodePointLayout::Builder('b', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont)
};
constexpr int denominatorSize = 6;
Layout layoutChildren[denominatorSize] = {
CodePointLayout::Builder('1', k_layoutFont),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('a', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('e', k_layoutFont),
VerticalOffsetLayout::Builder(
HorizontalLayout::Builder(exponentLayoutChildren, exponentSize),
m_layout = FractionLayout::Builder(
CodePointLayout::Builder('c', k_layoutFont),
HorizontalLayout::Builder({
CodePointLayout::Builder('1', k_layoutFont),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('a', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('e', k_layoutFont),
VerticalOffsetLayout::Builder(
HorizontalLayout::Builder({
CodePointLayout::Builder('-', k_layoutFont),
CodePointLayout::Builder('b', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont)
}),
VerticalOffsetLayoutNode::Position::Superscript
)
};
m_layout = FractionLayout::Builder(
CodePointLayout::Builder('c', k_layoutFont),
HorizontalLayout::Builder(layoutChildren, denominatorSize)
);
})
);
}
return m_layout;
}

12
apps/regression/model/power_model.cpp
View File

@@ -12,17 +12,15 @@ namespace Regression {
Layout PowerModel::layout() {
if (m_layout.isUninitialized()) {
constexpr int size = 4;
Layout layoutChildren[size] = {
m_layout = HorizontalLayout::Builder({
CodePointLayout::Builder('a', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
VerticalOffsetLayout::Builder(
CodePointLayout::Builder('b', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
};
m_layout = HorizontalLayout::Builder(layoutChildren, size);
CodePointLayout::Builder('b', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
});
}
return m_layout;
}

29
apps/regression/model/quadratic_model.cpp
View File

@@ -19,23 +19,21 @@ namespace Regression {
Layout QuadraticModel::layout() {
if (m_layout.isUninitialized()) {
constexpr int size = 10;
Layout layoutChildren[size] = {
m_layout = HorizontalLayout::Builder({
CodePointLayout::Builder('a', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
VerticalOffsetLayout::Builder(
CodePointLayout::Builder('2', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('2', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('b', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('c', k_layoutFont),
};
m_layout = HorizontalLayout::Builder(layoutChildren, size);
});
}
return m_layout;
}
@@ -69,19 +67,20 @@ Expression QuadraticModel::expression(double * modelCoefficients) {
double b = modelCoefficients[1];
double c = modelCoefficients[2];
// a*x^2+b*x+c
Expression addChildren[] = {
Multiplication::Builder(
return Addition::Builder({
Multiplication::Builder({
Number::DecimalNumber(a),
Power::Builder(
Symbol::Builder('x'),
Decimal::Builder(2.0))),
Multiplication::Builder(
Decimal::Builder(2.0)
)
}),
Multiplication::Builder({
Number::DecimalNumber(b),
Symbol::Builder('x')),
Symbol::Builder('x')
}),
Number::DecimalNumber(c)
};
Expression result = Addition::Builder(addChildren, 3);
return result;
});
}
}

59
apps/regression/model/quartic_model.cpp
View File

@@ -19,39 +19,37 @@ namespace Regression {
Layout QuarticModel::layout() {
if (m_layout.isUninitialized()) {
constexpr int size = 20;
Layout layoutChildren[size] = {
m_layout = HorizontalLayout::Builder({
CodePointLayout::Builder('a', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
VerticalOffsetLayout::Builder(
CodePointLayout::Builder('4', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('4', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('b', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
VerticalOffsetLayout::Builder(
CodePointLayout::Builder('3', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('3', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('c', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
VerticalOffsetLayout::Builder(
CodePointLayout::Builder('2', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('2', k_layoutFont),
VerticalOffsetLayoutNode::Position::Superscript
),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('d', k_layoutFont),
CodePointLayout::Builder(UCodePointMiddleDot, k_layoutFont),
CodePointLayout::Builder('X', k_layoutFont),
CodePointLayout::Builder('+', k_layoutFont),
CodePointLayout::Builder('e', k_layoutFont),
};
m_layout = HorizontalLayout::Builder(layoutChildren, size);
});
}
return m_layout;
}
@@ -96,34 +94,35 @@ Expression QuarticModel::expression(double * modelCoefficients) {
double c = modelCoefficients[2];
double d = modelCoefficients[3];
double e = modelCoefficients[4];
Expression addChildren[] = {
// a*x^4
Multiplication::Builder(
// a*x^4+b*x^3+c*x^2+d*x+e
return Addition::Builder({
Multiplication::Builder({
Number::DecimalNumber(a),
Power::Builder(
Symbol::Builder('x'),
Decimal::Builder(4.0))),
// b*x^3
Multiplication::Builder(
Decimal::Builder(4.0)
)
}),
Multiplication::Builder({
Number::DecimalNumber(b),
Power::Builder(
Symbol::Builder('x'),
Decimal::Builder(3.0))),
// c*x^2
Multiplication::Builder(
Decimal::Builder(3.0)
)
}),
Multiplication::Builder({
Number::DecimalNumber(c),
Power::Builder(
Symbol::Builder('x'),
Decimal::Builder(2.0))),
// d*x
Multiplication::Builder(
Decimal::Builder(2.0)
)
}),
Multiplication::Builder({
Number::DecimalNumber(d),
Symbol::Builder('x')),
// e
Symbol::Builder('x')
}),
Number::DecimalNumber(e)
};
Expression result = Addition::Builder(addChildren, 5);
return result;
});
}
}

2
poincare/include/poincare/absolute_value.h
View File

@@ -48,7 +48,7 @@ class AbsoluteValue final : public Expression {
friend class AbsoluteValueNode;
public:
AbsoluteValue(const AbsoluteValueNode * n) : Expression(n) {}
static AbsoluteValue Builder(Expression child) { return TreeHandle::FixedArityBuilder<AbsoluteValue, AbsoluteValueNode>(&child, 1); }
static AbsoluteValue Builder(Expression child) { return TreeHandle::FixedArityBuilder<AbsoluteValue, AbsoluteValueNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("abs", 1, &UntypedBuilderOneChild<AbsoluteValue>);

2
poincare/include/poincare/absolute_value_layout.h
View File

@@ -36,7 +36,7 @@ private:
class AbsoluteValueLayout final : public Layout {
public:
static AbsoluteValueLayout Builder(Layout child) { return TreeHandle::FixedArityBuilder<AbsoluteValueLayout, AbsoluteValueLayoutNode>(&child, 1); }
static AbsoluteValueLayout Builder(Layout child) { return TreeHandle::FixedArityBuilder<AbsoluteValueLayout, AbsoluteValueLayoutNode>({child}); }
AbsoluteValueLayout() = delete;
};

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

@@ -73,10 +73,12 @@ private:
class Addition final : public NAryExpression {
public:
Addition(const AdditionNode * n) : NAryExpression(n) {}
static Addition Builder() { return TreeHandle::NAryBuilder<Addition, AdditionNode>(); }
static Addition Builder(Expression e1) { return Addition::Builder(&e1, 1); }
static Addition Builder(Expression e1, Expression e2) { return Addition::Builder(ArrayBuilder<Expression>(e1, e2).array(), 2); }
static Addition Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder<Addition, AdditionNode>(children, numberOfChildren); }
static Addition Builder(const Tuple & children = {}) {
return TreeHandle::NAryBuilder<Addition, AdditionNode>(convert(children));
}
// TODO: Get rid of these two helper functions
static Addition Builder(Expression e1) { return Addition::Builder({e1}); }
static Addition Builder(Expression e1, Expression e2) { return Addition::Builder({e1, e2}); }
// Expression
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
Expression shallowBeautify(ExpressionNode::ReductionContext reductionContext);

2
poincare/include/poincare/arc_cosine.h
View File

@@ -45,7 +45,7 @@ private:
class ArcCosine final : public Expression {
public:
ArcCosine(const ArcCosineNode * n) : Expression(n) {}
static ArcCosine Builder(Expression child) { return TreeHandle::FixedArityBuilder<ArcCosine, ArcCosineNode>(&child, 1); }
static ArcCosine Builder(Expression child) { return TreeHandle::FixedArityBuilder<ArcCosine, ArcCosineNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("acos", 1, &UntypedBuilderOneChild<ArcCosine>);

2
poincare/include/poincare/arc_sine.h
View File

@@ -43,7 +43,7 @@ private:
class ArcSine final : public Expression {
public:
ArcSine(const ArcSineNode * n) : Expression(n) {}
static ArcSine Builder(Expression child) { return TreeHandle::FixedArityBuilder<ArcSine, ArcSineNode>(&child, 1); }
static ArcSine Builder(Expression child) { return TreeHandle::FixedArityBuilder<ArcSine, ArcSineNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("asin", 1, &UntypedBuilderOneChild<ArcSine>);

2
poincare/include/poincare/arc_tangent.h
View File

@@ -44,7 +44,7 @@ private:
class ArcTangent final : public Expression {
public:
ArcTangent(const ArcTangentNode * n) : Expression(n) {}
static ArcTangent Builder(Expression child) { return TreeHandle::FixedArityBuilder<ArcTangent, ArcTangentNode>(&child, 1); }
static ArcTangent Builder(Expression child) { return TreeHandle::FixedArityBuilder<ArcTangent, ArcTangentNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("atan", 1, &UntypedBuilderOneChild<ArcTangent>);

20
poincare/include/poincare/array_builder.h
View File

@@ -1,20 +0,0 @@
#ifndef POINCARE_ARRAY_BUILDER_H
#define POINCARE_ARRAY_BUILDER_H
namespace Poincare {
template <class T>
class ArrayBuilder {
public:
ArrayBuilder(T e1 = T(), T e2 = T(), T e3 = T(), T e4 = T()) :
m_data{e1, e2, e3, e4}
{}
T * array() { return const_cast<T *>(m_data); }
private:
T m_data[4];
};
}
#endif

2
poincare/include/poincare/binom_cdf.h
View File

@@ -37,7 +37,7 @@ private:
class BinomCDF final : public BinomialDistributionFunction {
public:
BinomCDF(const BinomCDFNode * n) : BinomialDistributionFunction(n) {}
static BinomCDF Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<BinomCDF, BinomCDFNode>(ArrayBuilder<TreeHandle>(child0, child1, child2).array(), 3); }
static BinomCDF Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<BinomCDF, BinomCDFNode>({child0, child1, child2}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("binomcdf", 3, &UntypedBuilderThreeChildren<BinomCDF>);
};

2
poincare/include/poincare/binom_pdf.h
View File

@@ -37,7 +37,7 @@ private:
class BinomPDF final : public BinomialDistributionFunction {
public:
BinomPDF(const BinomPDFNode * n) : BinomialDistributionFunction(n) {}
static BinomPDF Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<BinomPDF, BinomPDFNode>(ArrayBuilder<TreeHandle>(child0, child1, child2).array(), 3); }
static BinomPDF Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<BinomPDF, BinomPDFNode>({child0, child1, child2}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("binompdf", 3, &UntypedBuilderThreeChildren<BinomPDF>);
};

2
poincare/include/poincare/binomial_coefficient.h
View File

@@ -38,7 +38,7 @@ private:
class BinomialCoefficient final : public Expression {
public:
BinomialCoefficient(const BinomialCoefficientNode * n) : Expression(n) {}
static BinomialCoefficient Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<BinomialCoefficient, BinomialCoefficientNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static BinomialCoefficient Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<BinomialCoefficient, BinomialCoefficientNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("binomial", 2, &UntypedBuilderTwoChildren<BinomialCoefficient>);
// Expression

2
poincare/include/poincare/binomial_coefficient_layout.h
View File

@@ -46,7 +46,7 @@ private:
class BinomialCoefficientLayout final : public Layout {
public:
static BinomialCoefficientLayout Builder(Layout child0, Layout child1) { return TreeHandle::FixedArityBuilder<BinomialCoefficientLayout, BinomialCoefficientLayoutNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static BinomialCoefficientLayout Builder(Layout child0, Layout child1) { return TreeHandle::FixedArityBuilder<BinomialCoefficientLayout, BinomialCoefficientLayoutNode>({child0, child1}); }
BinomialCoefficientLayout() = delete;
};

2
poincare/include/poincare/ceiling.h
View File

@@ -41,7 +41,7 @@ private:
class Ceiling final : public Expression {
public:
Ceiling(const CeilingNode * n) : Expression(n) {}
static Ceiling Builder(Expression child) { return TreeHandle::FixedArityBuilder<Ceiling, CeilingNode>(&child, 1); }
static Ceiling Builder(Expression child) { return TreeHandle::FixedArityBuilder<Ceiling, CeilingNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("ceil", 1, &UntypedBuilderOneChild<Ceiling>);

2
poincare/include/poincare/ceiling_layout.h
View File

@@ -33,7 +33,7 @@ protected:
class CeilingLayout final : public Layout {
public:
static CeilingLayout Builder(Layout child) { return TreeHandle::FixedArityBuilder<CeilingLayout, CeilingLayoutNode>(&child, 1); }
static CeilingLayout Builder(Layout child) { return TreeHandle::FixedArityBuilder<CeilingLayout, CeilingLayoutNode>({child}); }
CeilingLayout() = delete;
};

2
poincare/include/poincare/complex_argument.h
View File

@@ -42,7 +42,7 @@ private:
class ComplexArgument final : public Expression {
public:
ComplexArgument(const ComplexArgumentNode * n) : Expression(n) {}
static ComplexArgument Builder(Expression child) { return TreeHandle::FixedArityBuilder<ComplexArgument, ComplexArgumentNode>(&child, 1); }
static ComplexArgument Builder(Expression child) { return TreeHandle::FixedArityBuilder<ComplexArgument, ComplexArgumentNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("arg", 1, &UntypedBuilderOneChild<ComplexArgument>);

2
poincare/include/poincare/complex_cartesian.h
View File

@@ -44,7 +44,7 @@ public:
ComplexCartesian() : Expression() {}
ComplexCartesian(const ComplexCartesianNode * node) : Expression(node) {}
static ComplexCartesian Builder() { return TreeHandle::FixedArityBuilder<ComplexCartesian, ComplexCartesianNode>(); }
static ComplexCartesian Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<ComplexCartesian, ComplexCartesianNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static ComplexCartesian Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<ComplexCartesian, ComplexCartesianNode>({child0, child1}); }
// Getters
Expression real() { return childAtIndex(0); }

2
poincare/include/poincare/condensed_sum_layout.h
View File

@@ -55,7 +55,7 @@ private:
class CondensedSumLayout final : public Layout {
public:
static CondensedSumLayout Builder(Layout base, Layout subscript, Layout superscript) { return TreeHandle::FixedArityBuilder<CondensedSumLayout, CondensedSumLayoutNode>(ArrayBuilder<TreeHandle>(base, subscript, superscript).array(), 3); }
static CondensedSumLayout Builder(Layout base, Layout subscript, Layout superscript) { return TreeHandle::FixedArityBuilder<CondensedSumLayout, CondensedSumLayoutNode>({base, subscript, superscript}); }
CondensedSumLayout() = delete;
};

4
poincare/include/poincare/confidence_interval.h
View File

@@ -48,7 +48,7 @@ class ConfidenceInterval : public Expression {
friend class SimplePredictionInterval;
public:
ConfidenceInterval(const ConfidenceIntervalNode * n) : Expression(n) {}
static ConfidenceInterval Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<ConfidenceInterval, ConfidenceIntervalNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static ConfidenceInterval Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<ConfidenceInterval, ConfidenceIntervalNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("confidence", 2, &UntypedBuilderTwoChildren<ConfidenceInterval>);
// Expression
@@ -60,7 +60,7 @@ private:
class SimplePredictionInterval final : public ConfidenceInterval {
public:
SimplePredictionInterval(const SimplePredictionIntervalNode * n) : ConfidenceInterval(n) {}
static SimplePredictionInterval Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<SimplePredictionInterval, SimplePredictionIntervalNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static SimplePredictionInterval Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<SimplePredictionInterval, SimplePredictionIntervalNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("prediction", 2, &UntypedBuilderTwoChildren<SimplePredictionInterval>);
};

2
poincare/include/poincare/conjugate.h
View File

@@ -42,7 +42,7 @@ private:
class Conjugate final : public Expression {
public:
Conjugate(const ConjugateNode * n) : Expression(n) {}
static Conjugate Builder(Expression child) { return TreeHandle::FixedArityBuilder<Conjugate, ConjugateNode>(&child, 1); }
static Conjugate Builder(Expression child) { return TreeHandle::FixedArityBuilder<Conjugate, ConjugateNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("conj", 1, &UntypedBuilderOneChild<Conjugate>);;

2
poincare/include/poincare/conjugate_layout.h
View File

@@ -43,7 +43,7 @@ private:
class ConjugateLayout final : public Layout {
public:
static ConjugateLayout Builder(Layout child) { return TreeHandle::FixedArityBuilder<ConjugateLayout, ConjugateLayoutNode>(&child, 1); }
static ConjugateLayout Builder(Layout child) { return TreeHandle::FixedArityBuilder<ConjugateLayout, ConjugateLayoutNode>({child}); }
ConjugateLayout() = delete;
};

2
poincare/include/poincare/cosine.h
View File

@@ -46,7 +46,7 @@ private:
class Cosine final : public Expression {
public:
Cosine(const CosineNode * n) : Expression(n) {}
static Cosine Builder(Expression child) { return TreeHandle::FixedArityBuilder<Cosine, CosineNode>(&child, 1); }
static Cosine Builder(Expression child) { return TreeHandle::FixedArityBuilder<Cosine, CosineNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("cos", 1, &UntypedBuilderOneChild<Cosine>);

2
poincare/include/poincare/derivative.h
View File

@@ -49,7 +49,7 @@ private:
class Derivative final : public ParameteredExpression {
public:
Derivative(const DerivativeNode * n) : ParameteredExpression(n) {}
static Derivative Builder(Expression child0, Symbol child1, Expression child2) { return TreeHandle::FixedArityBuilder<Derivative, DerivativeNode>(ArrayBuilder<TreeHandle>(child0, child1, child2).array(), 3); }
static Derivative Builder(Expression child0, Symbol child1, Expression child2) { return TreeHandle::FixedArityBuilder<Derivative, DerivativeNode>({child0, child1, child2}); }
static Expression UntypedBuilder(Expression children);
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("diff", 3, &UntypedBuilder);

2
poincare/include/poincare/determinant.h
View File

@@ -37,7 +37,7 @@ private:
class Determinant final : public Expression {
public:
Determinant(const DeterminantNode * n) : Expression(n) {}
static Determinant Builder(Expression child) { return TreeHandle::FixedArityBuilder<Determinant, DeterminantNode>(&child, 1); }
static Determinant Builder(Expression child) { return TreeHandle::FixedArityBuilder<Determinant, DeterminantNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("det", 1, &UntypedBuilderOneChild<Determinant>);

2
poincare/include/poincare/division.h
View File

@@ -64,7 +64,7 @@ class Division final : public Expression {
public:
Division(const DivisionNode * n) : Expression(n) {}
static Division Builder() { return TreeHandle::FixedArityBuilder<Division, DivisionNode>(); }
static Division Builder(Expression numerator, Expression denominator) { return TreeHandle::FixedArityBuilder<Division, DivisionNode>(ArrayBuilder<TreeHandle>(numerator, denominator).array(), 2); }
static Division Builder(Expression numerator, Expression denominator) { return TreeHandle::FixedArityBuilder<Division, DivisionNode>({numerator, denominator}); }
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
};

2
poincare/include/poincare/division_quotient.h
View File

@@ -40,7 +40,7 @@ private:
class DivisionQuotient final : public Expression {
public:
DivisionQuotient(const DivisionQuotientNode * n) : Expression(n) {}
static DivisionQuotient Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<DivisionQuotient, DivisionQuotientNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static DivisionQuotient Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<DivisionQuotient, DivisionQuotientNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("quo", 2, &UntypedBuilderTwoChildren<DivisionQuotient>);
// Expression

2
poincare/include/poincare/division_remainder.h
View File

@@ -42,7 +42,7 @@ private:
class DivisionRemainder final : public Expression {
public:
DivisionRemainder(const DivisionRemainderNode * n) : Expression(n) {}
static DivisionRemainder Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<DivisionRemainder, DivisionRemainderNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static DivisionRemainder Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<DivisionRemainder, DivisionRemainderNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("rem", 2, &UntypedBuilderTwoChildren<DivisionRemainder>);
// Expression

2
poincare/include/poincare/equal.h
View File

@@ -36,7 +36,7 @@ private:
class Equal final : public Expression {
public:
Equal(const EqualNode * n) : Expression(n) {}
static Equal Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Equal, EqualNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static Equal Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Equal, EqualNode>({child0, child1}); }
// For the equation A = B, create the reduced expression A-B
Expression standardEquation(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;

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

@@ -1,7 +1,6 @@
#ifndef POINCARE_EXPRESSION_REFERENCE_H
#define POINCARE_EXPRESSION_REFERENCE_H
#include <poincare/array_builder.h>
#include <poincare/coordinate_2D.h>
#include <poincare/tree_handle.h>
#include <poincare/preferences.h>
@@ -286,6 +285,9 @@ public:
static void Tidy() { sSymbolReplacementsCountLock = false; }
/* Tuple */
typedef std::initializer_list<Expression> Tuple;
protected:
static bool SimplificationHasBeenInterrupted();
Expression(const ExpressionNode * n) : TreeHandle(n) {}
@@ -328,6 +330,12 @@ protected:
return *reinterpret_cast<T *>(const_cast<Expression *>(this));
}
static_assert(sizeof(TreeHandle::Tuple) == sizeof(Tuple), "Size mismatch");
static const TreeHandle::Tuple & convert(const Tuple & l) {
assert(sizeof(TreeHandle) == sizeof(Expression));
return reinterpret_cast<const TreeHandle::Tuple &>(l);
}
/* Reference */
ExpressionNode * node() const {
assert(identifier() != TreeNode::NoNodeIdentifier || !TreeHandle::node()->isGhost());

2
poincare/include/poincare/factor.h
View File

@@ -39,7 +39,7 @@ private:
class Factor final : public Expression {
public:
Factor(const FactorNode * n) : Expression(n) {}
static Factor Builder(Expression child) { return TreeHandle::FixedArityBuilder<Factor, FactorNode>(&child, 1); }
static Factor Builder(Expression child) { return TreeHandle::FixedArityBuilder<Factor, FactorNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("factor", 1, &UntypedBuilderOneChild<Factor>);

2
poincare/include/poincare/factorial.h
View File

@@ -52,7 +52,7 @@ private:
class Factorial final : public Expression {
public:
Factorial(const FactorialNode * n) : Expression(n) {}
static Factorial Builder(Expression child) { return TreeHandle::FixedArityBuilder<Factorial, FactorialNode>(&child, 1); }
static Factorial Builder(Expression child) { return TreeHandle::FixedArityBuilder<Factorial, FactorialNode>({child}); }
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
private:

2
poincare/include/poincare/floor.h
View File

@@ -42,7 +42,7 @@ private:
class Floor final : public Expression {
public:
Floor(const FloorNode * n) : Expression(n) {}
static Floor Builder(Expression child) { return TreeHandle::FixedArityBuilder<Floor, FloorNode>(&child, 1); }
static Floor Builder(Expression child) { return TreeHandle::FixedArityBuilder<Floor, FloorNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("floor", 1, &UntypedBuilderOneChild<Floor>);

2
poincare/include/poincare/floor_layout.h
View File

@@ -33,7 +33,7 @@ protected:
class FloorLayout final : public Layout {
public:
static FloorLayout Builder(Layout child) { return TreeHandle::FixedArityBuilder<FloorLayout, FloorLayoutNode>(&child, 1); }
static FloorLayout Builder(Layout child) { return TreeHandle::FixedArityBuilder<FloorLayout, FloorLayoutNode>({child}); }
FloorLayout() = delete;
};

2
poincare/include/poincare/frac_part.h
View File

@@ -45,7 +45,7 @@ private:
class FracPart final : public Expression {
public:
FracPart(const FracPartNode * n) : Expression(n) {}
static FracPart Builder(Expression child) { return TreeHandle::FixedArityBuilder<FracPart, FracPartNode>(&child, 1); }
static FracPart Builder(Expression child) { return TreeHandle::FixedArityBuilder<FracPart, FracPartNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("frac", 1, &UntypedBuilderOneChild<FracPart>);

2
poincare/include/poincare/fraction_layout.h
View File

@@ -61,7 +61,7 @@ private:
class FractionLayout final : public Layout {
public:
static FractionLayout Builder(Layout child0, Layout child1) { return TreeHandle::FixedArityBuilder<FractionLayout, FractionLayoutNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static FractionLayout Builder(Layout child0, Layout child1) { return TreeHandle::FixedArityBuilder<FractionLayout, FractionLayoutNode>({child0, child1}); }
FractionLayout() = delete;
};

2
poincare/include/poincare/great_common_divisor.h
View File

@@ -37,7 +37,7 @@ private:
class GreatCommonDivisor final : public Expression {
public:
GreatCommonDivisor(const GreatCommonDivisorNode * n) : Expression(n) {}
static GreatCommonDivisor Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<GreatCommonDivisor, GreatCommonDivisorNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static GreatCommonDivisor Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<GreatCommonDivisor, GreatCommonDivisorNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("gcd", 2, &UntypedBuilderTwoChildren<GreatCommonDivisor>);
// Expression

14
poincare/include/poincare/horizontal_layout.h
View File

@@ -75,12 +75,14 @@ class HorizontalLayout final : public Layout {
public:
// Constructors
HorizontalLayout(HorizontalLayoutNode * n) : Layout(n) {}
static HorizontalLayout Builder() { return TreeHandle::NAryBuilder<HorizontalLayout,HorizontalLayoutNode>(); }
static HorizontalLayout Builder(Layout l) { return HorizontalLayout::Builder(&l, 1); }
static HorizontalLayout Builder(Layout l1, Layout l2) { return HorizontalLayout::Builder(ArrayBuilder<Layout>(l1, l2).array(), 2); }
static HorizontalLayout Builder(Layout l1, Layout l2, Layout l3) { return HorizontalLayout::Builder(ArrayBuilder<Layout>(l1, l2, l3).array(), 3); }
static HorizontalLayout Builder(Layout l1, Layout l2, Layout l3, Layout l4) { return HorizontalLayout::Builder(ArrayBuilder<Layout>(l1, l2, l3, l4).array(), 4); }
static HorizontalLayout Builder(Layout * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder<HorizontalLayout,HorizontalLayoutNode>(static_cast<TreeHandle *>(children), numberOfChildren); }
// FIXME: use Layout instead of TreeHandle
static HorizontalLayout Builder(std::initializer_list<TreeHandle> children = {}) { return TreeHandle::NAryBuilder<HorizontalLayout,HorizontalLayoutNode>(children); }
// TODO: Get rid of those helpers
static HorizontalLayout Builder(Layout l) { return Builder({l}); }
static HorizontalLayout Builder(Layout l1, Layout l2) { return Builder({l1, l2}); }
static HorizontalLayout Builder(Layout l1, Layout l2, Layout l3) { return Builder({l1, l2, l3}); }
static HorizontalLayout Builder(Layout l1, Layout l2, Layout l3, Layout l4) { return Builder({l1, l2, l3, l4}); }
void addChildAtIndex(Layout l, int index, int currentNumberOfChildren, LayoutCursor * cursor, bool removeEmptyChildren = false);
// Remove puts a child at the end of the pool

2
poincare/include/poincare/hyperbolic_arc_cosine.h
View File

@@ -38,7 +38,7 @@ private:
class HyperbolicArcCosine final : public HyperbolicTrigonometricFunction {
public:
HyperbolicArcCosine(const HyperbolicArcCosineNode * n) : HyperbolicTrigonometricFunction(n) {}
static HyperbolicArcCosine Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicArcCosine, HyperbolicArcCosineNode>(&child, 1); }
static HyperbolicArcCosine Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicArcCosine, HyperbolicArcCosineNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("acosh", 1, &UntypedBuilderOneChild<HyperbolicArcCosine>);
};

2
poincare/include/poincare/hyperbolic_arc_sine.h
View File

@@ -36,7 +36,7 @@ private:
class HyperbolicArcSine final : public HyperbolicTrigonometricFunction {
public:
HyperbolicArcSine(const HyperbolicArcSineNode * n) : HyperbolicTrigonometricFunction(n) {}
static HyperbolicArcSine Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicArcSine, HyperbolicArcSineNode>(&child, 1); }
static HyperbolicArcSine Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicArcSine, HyperbolicArcSineNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("asinh", 1, &UntypedBuilderOneChild<HyperbolicArcSine>);
};

2
poincare/include/poincare/hyperbolic_arc_tangent.h
View File

@@ -36,7 +36,7 @@ private:
class HyperbolicArcTangent final : public HyperbolicTrigonometricFunction {
public:
HyperbolicArcTangent(const HyperbolicArcTangentNode * n) : HyperbolicTrigonometricFunction(n) {}
static HyperbolicArcTangent Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicArcTangent, HyperbolicArcTangentNode>(&child, 1); }
static HyperbolicArcTangent Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicArcTangent, HyperbolicArcTangentNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("atanh", 1, &UntypedBuilderOneChild<HyperbolicArcTangent>);
};

2
poincare/include/poincare/hyperbolic_cosine.h
View File

@@ -38,7 +38,7 @@ private:
class HyperbolicCosine final : public HyperbolicTrigonometricFunction {
public:
HyperbolicCosine(const HyperbolicCosineNode * n) : HyperbolicTrigonometricFunction(n) {}
static HyperbolicCosine Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicCosine, HyperbolicCosineNode>(&child, 1); }
static HyperbolicCosine Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicCosine, HyperbolicCosineNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("cosh", 1, &UntypedBuilderOneChild<HyperbolicCosine>);
};

2
poincare/include/poincare/hyperbolic_sine.h
View File

@@ -36,7 +36,7 @@ private:
class HyperbolicSine final : public HyperbolicTrigonometricFunction {
public:
HyperbolicSine(const HyperbolicSineNode * n) : HyperbolicTrigonometricFunction(n) {}
static HyperbolicSine Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicSine, HyperbolicSineNode>(&child, 1); }
static HyperbolicSine Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicSine, HyperbolicSineNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("sinh", 1, &UntypedBuilderOneChild<HyperbolicSine>);
};

2
poincare/include/poincare/hyperbolic_tangent.h
View File

@@ -36,7 +36,7 @@ private:
class HyperbolicTangent final : public HyperbolicTrigonometricFunction {
public:
HyperbolicTangent(const HyperbolicTangentNode * n) : HyperbolicTrigonometricFunction(n) {}
static HyperbolicTangent Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicTangent, HyperbolicTangentNode>(&child, 1); }
static HyperbolicTangent Builder(Expression child) { return TreeHandle::FixedArityBuilder<HyperbolicTangent, HyperbolicTangentNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("tanh", 1, &UntypedBuilderOneChild<HyperbolicTangent>);
};

2
poincare/include/poincare/imaginary_part.h
View File

@@ -45,7 +45,7 @@ private:
class ImaginaryPart final : public Expression {
public:
ImaginaryPart(const ImaginaryPartNode * n) : Expression(n) {}
static ImaginaryPart Builder(Expression child) { return TreeHandle::FixedArityBuilder<ImaginaryPart, ImaginaryPartNode>(&child, 1); }
static ImaginaryPart Builder(Expression child) { return TreeHandle::FixedArityBuilder<ImaginaryPart, ImaginaryPartNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("im", 1, &UntypedBuilderOneChild<ImaginaryPart>);

2
poincare/include/poincare/integral.h
View File

@@ -53,7 +53,7 @@ private:
class Integral final : public ParameteredExpression {
public:
Integral(const IntegralNode * n) : ParameteredExpression(n) {}
static Integral Builder(Expression child0, Symbol child1, Expression child2, Expression child3) { return TreeHandle::FixedArityBuilder<Integral, IntegralNode>(ArrayBuilder<TreeHandle>(child0, child1, child2, child3).array(), 4); }
static Integral Builder(Expression child0, Symbol child1, Expression child2, Expression child3) { return TreeHandle::FixedArityBuilder<Integral, IntegralNode>({child0, child1, child2, child3}); }
static Expression UntypedBuilder(Expression children);
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("int", 4, &UntypedBuilder);

2
poincare/include/poincare/integral_layout.h
View File

@@ -61,7 +61,7 @@ private:
class IntegralLayout final : public Layout {
public:
static IntegralLayout Builder(Layout integrand, Layout differential, Layout lowerBound, Layout upperBound) { return TreeHandle::FixedArityBuilder<IntegralLayout, IntegralLayoutNode>(ArrayBuilder<TreeHandle>(integrand, differential, lowerBound, upperBound).array(), 4); }
static IntegralLayout Builder(Layout integrand, Layout differential, Layout lowerBound, Layout upperBound) { return TreeHandle::FixedArityBuilder<IntegralLayout, IntegralLayoutNode>({integrand, differential, lowerBound, upperBound}); }
IntegralLayout() = delete;
};

2
poincare/include/poincare/inv_binom.h
View File

@@ -38,7 +38,7 @@ private:
class InvBinom final : public BinomialDistributionFunction {
public:
InvBinom(const InvBinomNode * n) : BinomialDistributionFunction(n) {}
static InvBinom Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<InvBinom, InvBinomNode>(ArrayBuilder<TreeHandle>(child0, child1, child2).array(), 3); }
static InvBinom Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<InvBinom, InvBinomNode>({child0, child1, child2}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("invbinom", 3, &UntypedBuilderThreeChildren<InvBinom>);
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
};

2
poincare/include/poincare/inv_norm.h
View File

@@ -38,7 +38,7 @@ private:
class InvNorm final : public NormalDistributionFunction {
public:
InvNorm(const InvNormNode * n) : NormalDistributionFunction(n) {}
static InvNorm Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<InvNorm, InvNormNode>(ArrayBuilder<TreeHandle>(child0, child1, child2).array(), 3); }
static InvNorm Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<InvNorm, InvNormNode>({child0, child1, child2}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("invnorm", 3, &UntypedBuilderThreeChildren<InvNorm>);
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
};

1
poincare/include/poincare/layout.h
View File

@@ -1,7 +1,6 @@
#ifndef POINCARE_LAYOUT_REFERENCE_H
#define POINCARE_LAYOUT_REFERENCE_H
#include <poincare/array_builder.h>
#include <poincare/context.h>
#include <poincare/layout_node.h>
#include <poincare/tree_handle.h>

2
poincare/include/poincare/least_common_multiple.h
View File

@@ -37,7 +37,7 @@ private:
class LeastCommonMultiple final : public Expression {
public:
LeastCommonMultiple(const LeastCommonMultipleNode * n) : Expression(n) {}
static LeastCommonMultiple Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<LeastCommonMultiple, LeastCommonMultipleNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static LeastCommonMultiple Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<LeastCommonMultiple, LeastCommonMultipleNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("lcm", 2, &UntypedBuilderTwoChildren<LeastCommonMultiple>);
// Expression

4
poincare/include/poincare/logarithm.h
View File

@@ -48,7 +48,7 @@ class Logarithm final : public Expression {
friend class LogarithmNode<2>;
public:
Logarithm(const LogarithmNode<2> * n) : Expression(n) {}
static Logarithm Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Logarithm, LogarithmNode<2>>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static Logarithm Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Logarithm, LogarithmNode<2>>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("log", 2, &UntypedBuilderTwoChildren<Logarithm>);
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
@@ -65,7 +65,7 @@ private:
class CommonLogarithm : public Expression {
public:
CommonLogarithm(const LogarithmNode<1> * n) : Expression(n) {}
static CommonLogarithm Builder(Expression child) { return TreeHandle::FixedArityBuilder<CommonLogarithm, LogarithmNode<1>>(&child, 1); }
static CommonLogarithm Builder(Expression child) { return TreeHandle::FixedArityBuilder<CommonLogarithm, LogarithmNode<1>>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("log", 1, &UntypedBuilderOneChild<CommonLogarithm>);

2
poincare/include/poincare/matrix_dimension.h
View File

@@ -37,7 +37,7 @@ private:
class MatrixDimension final : public Expression {
public:
MatrixDimension(const MatrixDimensionNode * n) : Expression(n) {}
static MatrixDimension Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixDimension, MatrixDimensionNode>(&child, 1); }
static MatrixDimension Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixDimension, MatrixDimensionNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("dim", 1, &UntypedBuilderOneChild<MatrixDimension>);

2
poincare/include/poincare/matrix_identity.h
View File

@@ -35,7 +35,7 @@ private:
class MatrixIdentity final : public Expression {
public:
MatrixIdentity(const MatrixIdentityNode * n) : Expression(n) {}
static MatrixIdentity Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixIdentity, MatrixIdentityNode>(&child, 1); }
static MatrixIdentity Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixIdentity, MatrixIdentityNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("identity", 1, &UntypedBuilderOneChild<MatrixIdentity>);

2
poincare/include/poincare/matrix_inverse.h
View File

@@ -36,7 +36,7 @@ private:
class MatrixInverse final : public Expression {
public:
MatrixInverse(const MatrixInverseNode * n) : Expression(n) {}
static MatrixInverse Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixInverse, MatrixInverseNode>(&child, 1); }
static MatrixInverse Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixInverse, MatrixInverseNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("inverse", 1, &UntypedBuilderOneChild<MatrixInverse>);

2
poincare/include/poincare/matrix_trace.h
View File

@@ -36,7 +36,7 @@ private:
class MatrixTrace final : public Expression {
public:
MatrixTrace(const MatrixTraceNode * n) : Expression(n) {}
static MatrixTrace Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixTrace, MatrixTraceNode>(&child, 1); }
static MatrixTrace Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixTrace, MatrixTraceNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("trace", 1, &UntypedBuilderOneChild<MatrixTrace>);

2
poincare/include/poincare/matrix_transpose.h
View File

@@ -36,7 +36,7 @@ private:
class MatrixTranspose final : public Expression {
public:
MatrixTranspose(const MatrixTransposeNode * n) : Expression(n) {}
static MatrixTranspose Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixTranspose, MatrixTransposeNode>(&child, 1); }
static MatrixTranspose Builder(Expression child) { return TreeHandle::FixedArityBuilder<MatrixTranspose, MatrixTransposeNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("transpose", 1, &UntypedBuilderOneChild<MatrixTranspose>);

12
poincare/include/poincare/multiplication.h
View File

@@ -69,12 +69,12 @@ class Multiplication : public NAryExpression {
friend class UnitConvert;
public:
Multiplication(const MultiplicationNode * n) : NAryExpression(n) {}
static Multiplication Builder() { return TreeHandle::NAryBuilder<Multiplication, MultiplicationNode>(); }
static Multiplication Builder(Expression e1) { return Multiplication::Builder(&e1, 1); }
static Multiplication Builder(Expression e1, Expression e2) { return Multiplication::Builder(ArrayBuilder<Expression>(e1, e2).array(), 2); }
static Multiplication Builder(Expression e1, Expression e2, Expression e3) { return Multiplication::Builder(ArrayBuilder<Expression>(e1, e2, e3).array(), 3); }
static Multiplication Builder(Expression e1, Expression e2, Expression e3, Expression e4) { return Multiplication::Builder(ArrayBuilder<Expression>(e1, e2, e3, e4).array(), 4); }
static Multiplication Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder<Multiplication, MultiplicationNode>(children, numberOfChildren); }
static Multiplication Builder(const Tuple & children = {}) { return TreeHandle::NAryBuilder<Multiplication, MultiplicationNode>(convert(children)); }
// TODO: Get rid of those helpers
static Multiplication Builder(Expression e1) { return Multiplication::Builder({e1}); }
static Multiplication Builder(Expression e1, Expression e2) { return Multiplication::Builder({e1, e2}); }
static Multiplication Builder(Expression e1, Expression e2, Expression e3) { return Multiplication::Builder({e1, e2, e3}); }
static Multiplication Builder(Expression e1, Expression e2, Expression e3, Expression e4) { return Multiplication::Builder({e1, e2, e3, e4}); }
// Properties
int getPolynomialCoefficients(Context * context, const char * symbolName, Expression coefficients[], ExpressionNode::SymbolicComputation symbolicComputation) const;

2
poincare/include/poincare/naperian_logarithm.h
View File

@@ -46,7 +46,7 @@ private:
class NaperianLogarithm final : public Expression {
public:
NaperianLogarithm(const NaperianLogarithmNode * n) : Expression(n) {}
static NaperianLogarithm Builder(Expression child) { return TreeHandle::FixedArityBuilder<NaperianLogarithm, NaperianLogarithmNode>(&child, 1); }
static NaperianLogarithm Builder(Expression child) { return TreeHandle::FixedArityBuilder<NaperianLogarithm, NaperianLogarithmNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("ln", 1, &UntypedBuilderOneChild<NaperianLogarithm>);

2
poincare/include/poincare/norm_cdf.h
View File

@@ -37,7 +37,7 @@ private:
class NormCDF final : public NormalDistributionFunction {
public:
NormCDF(const NormCDFNode * n) : NormalDistributionFunction(n) {}
static NormCDF Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<NormCDF, NormCDFNode>(ArrayBuilder<TreeHandle>(child0, child1, child2).array(), 3); }
static NormCDF Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<NormCDF, NormCDFNode>({child0, child1, child2}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("normcdf", 3, &UntypedBuilderThreeChildren<NormCDF>);
};

2
poincare/include/poincare/norm_cdf2.h
View File

@@ -39,7 +39,7 @@ private:
class NormCDF2 final : public NormalDistributionFunction {
public:
NormCDF2(const NormCDF2Node * n) : NormalDistributionFunction(n) {}
static NormCDF2 Builder(Expression child0, Expression child1, Expression child2, Expression child3) { return TreeHandle::FixedArityBuilder<NormCDF2, NormCDF2Node>(ArrayBuilder<TreeHandle>(child0, child1, child2, child3).array(), 4); }
static NormCDF2 Builder(Expression child0, Expression child1, Expression child2, Expression child3) { return TreeHandle::FixedArityBuilder<NormCDF2, NormCDF2Node>({child0, child1, child2, child3}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("normcdf2", 4, &UntypedBuilderFourChildren<NormCDF2>);
};

2
poincare/include/poincare/norm_pdf.h
View File

@@ -37,7 +37,7 @@ private:
class NormPDF final : public NormalDistributionFunction {
public:
NormPDF(const NormPDFNode * n) : NormalDistributionFunction(n) {}
static NormPDF Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<NormPDF, NormPDFNode>(ArrayBuilder<TreeHandle>(child0, child1, child2).array(), 3); }
static NormPDF Builder(Expression child0, Expression child1, Expression child2) { return TreeHandle::FixedArityBuilder<NormPDF, NormPDFNode>({child0, child1, child2}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("normpdf", 3, &UntypedBuilderThreeChildren<NormPDF>);
};

2
poincare/include/poincare/nth_root.h
View File

@@ -38,7 +38,7 @@ private:
class NthRoot final : public Expression {
public:
NthRoot(const NthRootNode * n) : Expression(n) {}
static NthRoot Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<NthRoot, NthRootNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static NthRoot Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<NthRoot, NthRootNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("root", 2, &UntypedBuilderTwoChildren<NthRoot>);
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);

2
poincare/include/poincare/opposite.h
View File

@@ -50,7 +50,7 @@ class Opposite final : public Expression {
public:
Opposite(const OppositeNode * n) : Expression(n) {}
static Opposite Builder() { return TreeHandle::FixedArityBuilder<Opposite, OppositeNode>(); }
static Opposite Builder(Expression child) { return TreeHandle::FixedArityBuilder<Opposite, OppositeNode>(&child, 1); }
static Opposite Builder(Expression child) { return TreeHandle::FixedArityBuilder<Opposite, OppositeNode>({child}); }
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
};

2
poincare/include/poincare/parenthesis.h
View File

@@ -40,7 +40,7 @@ private:
class Parenthesis final : public Expression {
public:
Parenthesis(const ParenthesisNode * n) : Expression(n) {}
static Parenthesis Builder(Expression child) { return TreeHandle::FixedArityBuilder<Parenthesis, ParenthesisNode>(&child, 1); }
static Parenthesis Builder(Expression child) { return TreeHandle::FixedArityBuilder<Parenthesis, ParenthesisNode>({child}); }
// Expression
Expression shallowReduce();
};

2
poincare/include/poincare/permute_coefficient.h
View File

@@ -41,7 +41,7 @@ private:
class PermuteCoefficient final : public Expression {
public:
PermuteCoefficient(const PermuteCoefficientNode * n) : Expression(n) {}
static PermuteCoefficient Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<PermuteCoefficient, PermuteCoefficientNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static PermuteCoefficient Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<PermuteCoefficient, PermuteCoefficientNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("permute", 2, &UntypedBuilderTwoChildren<PermuteCoefficient>);
// Expression

2
poincare/include/poincare/power.h
View File

@@ -73,7 +73,7 @@ class Power final : public Expression {
friend class Round;
public:
Power(const PowerNode * n) : Expression(n) {}
static Power Builder(Expression base, Expression exponent) { return TreeHandle::FixedArityBuilder<Power, PowerNode>(ArrayBuilder<TreeHandle>(base, exponent).array(), 2); }
static Power Builder(Expression base, Expression exponent) { return TreeHandle::FixedArityBuilder<Power, PowerNode>({base, exponent}); }
Expression setSign(ExpressionNode::Sign s, ExpressionNode::ReductionContext reductionContext);
int getPolynomialCoefficients(Context * context, const char * symbolName, Expression coefficients[]) const;

2
poincare/include/poincare/prediction_interval.h
View File

@@ -39,7 +39,7 @@ private:
class PredictionInterval final : public Expression {
public:
PredictionInterval(const PredictionIntervalNode * n) : Expression(n) {}
static PredictionInterval Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<PredictionInterval, PredictionIntervalNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static PredictionInterval Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<PredictionInterval, PredictionIntervalNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("prediction95", 2, &UntypedBuilderTwoChildren<PredictionInterval>);
// Expression

2
poincare/include/poincare/product.h
View File

@@ -34,7 +34,7 @@ class Product final : public Sequence {
friend class ProductNode;
public:
Product(const ProductNode * n) : Sequence(n) {}
static Product Builder(Expression child0, Symbol child1, Expression child2, Expression child3) { return TreeHandle::FixedArityBuilder<Product, ProductNode>(ArrayBuilder<TreeHandle>(child0, child1, child2, child3).array(), 4); }
static Product Builder(Expression child0, Symbol child1, Expression child2, Expression child3) { return TreeHandle::FixedArityBuilder<Product, ProductNode>({child0, child1, child2, child3}); }
static Expression UntypedBuilder(Expression children);
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("product", 4, &UntypedBuilder);

2
poincare/include/poincare/product_layout.h
View File

@@ -29,7 +29,7 @@ private:
class ProductLayout final : public Layout {
public:
static ProductLayout Builder(Layout argument, Layout variable, Layout lowerB, Layout upperB) { return TreeHandle::FixedArityBuilder<ProductLayout,ProductLayoutNode>(ArrayBuilder<TreeHandle>(argument, variable, lowerB, upperB).array(), 4); }
static ProductLayout Builder(Layout argument, Layout variable, Layout lowerB, Layout upperB) { return TreeHandle::FixedArityBuilder<ProductLayout,ProductLayoutNode>({argument, variable, lowerB, upperB}); }
ProductLayout() = delete;
};

2
poincare/include/poincare/randint.h
View File

@@ -45,7 +45,7 @@ class Randint final : public Expression {
friend class RandintNode;
public:
Randint(const RandintNode * n) : Expression(n) {}
static Randint Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Randint, RandintNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static Randint Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Randint, RandintNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("randint", 2, &UntypedBuilderTwoChildren<Randint>);
private:
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);

2
poincare/include/poincare/real_part.h
View File

@@ -45,7 +45,7 @@ private:
class RealPart final : public Expression {
public:
RealPart(const RealPartNode * n) : Expression(n) {}
static RealPart Builder(Expression child) { return TreeHandle::FixedArityBuilder<RealPart, RealPartNode>(&child, 1); }
static RealPart Builder(Expression child) { return TreeHandle::FixedArityBuilder<RealPart, RealPartNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("re", 1, &UntypedBuilderOneChild<RealPart>);

2
poincare/include/poincare/round.h
View File

@@ -38,7 +38,7 @@ private:
class Round final : public Expression {
public:
Round(const RoundNode * n) : Expression(n) {}
static Round Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Round, RoundNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static Round Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Round, RoundNode>({child0, child1}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("round", 2, &UntypedBuilderTwoChildren<Round>);
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);

2
poincare/include/poincare/sign_function.h
View File

@@ -45,7 +45,7 @@ private:
class SignFunction final : public Expression {
public:
SignFunction(const SignFunctionNode * n) : Expression(n) {}
static SignFunction Builder(Expression child) { return TreeHandle::FixedArityBuilder<SignFunction, SignFunctionNode>(&child, 1); }
static SignFunction Builder(Expression child) { return TreeHandle::FixedArityBuilder<SignFunction, SignFunctionNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("sign", 1, &UntypedBuilderOneChild<SignFunction>);

2
poincare/include/poincare/sine.h
View File

@@ -47,7 +47,7 @@ private:
class Sine final : public Expression {
public:
Sine(const SineNode * n) : Expression(n) {}
static Sine Builder(Expression child) { return TreeHandle::FixedArityBuilder<Sine, SineNode>(&child, 1); }
static Sine Builder(Expression child) { return TreeHandle::FixedArityBuilder<Sine, SineNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("sin", 1, &UntypedBuilderOneChild<Sine>);

2
poincare/include/poincare/square_root.h
View File

@@ -41,7 +41,7 @@ private:
class SquareRoot final : public Expression {
public:
SquareRoot(const SquareRootNode * n) : Expression(n) {}
static SquareRoot Builder(Expression child) { return TreeHandle::FixedArityBuilder<SquareRoot, SquareRootNode>(&child, 1); }
static SquareRoot Builder(Expression child) { return TreeHandle::FixedArityBuilder<SquareRoot, SquareRootNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("√", 1, &UntypedBuilderOneChild<SquareRoot>);
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
};

2
poincare/include/poincare/store.h
View File

@@ -32,7 +32,7 @@ class Store final : public Expression {
friend class StoreNode;
public:
Store(const StoreNode * n) : Expression(n) {}
static Store Builder(Expression value, SymbolAbstract symbol) { return TreeHandle::FixedArityBuilder<Store, StoreNode>(ArrayBuilder<TreeHandle>(value, symbol).array(), 2); }
static Store Builder(Expression value, SymbolAbstract symbol) { return TreeHandle::FixedArityBuilder<Store, StoreNode>({value, symbol}); }
// Store
const SymbolAbstract symbol() const {

2
poincare/include/poincare/subtraction.h
View File

@@ -62,7 +62,7 @@ class Subtraction final : public Expression {
public:
Subtraction(const SubtractionNode * n) : Expression(n) {}
static Subtraction Builder() { return TreeHandle::FixedArityBuilder<Subtraction, SubtractionNode>(); }
static Subtraction Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Subtraction, SubtractionNode>(ArrayBuilder<TreeHandle>(child0, child1).array(), 2); }
static Subtraction Builder(Expression child0, Expression child1) { return TreeHandle::FixedArityBuilder<Subtraction, SubtractionNode>({child0, child1}); }
// Expression
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);

2
poincare/include/poincare/sum.h
View File

@@ -34,7 +34,7 @@ class Sum final : public Sequence {
friend class SumNode;
public:
Sum(const SumNode * n) : Sequence(n) {}
static Sum Builder(Expression child0, Symbol child1, Expression child2, Expression child3) { return TreeHandle::FixedArityBuilder<Sum, SumNode>(ArrayBuilder<TreeHandle>(child0, child1, child2, child3).array(), 4); }
static Sum Builder(Expression child0, Symbol child1, Expression child2, Expression child3) { return TreeHandle::FixedArityBuilder<Sum, SumNode>({child0, child1, child2, child3}); }
static Expression UntypedBuilder(Expression children);
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("sum", 4, &UntypedBuilder);

2
poincare/include/poincare/sum_layout.h
View File

@@ -27,7 +27,7 @@ private:
class SumLayout final : public Layout {
public:
static SumLayout Builder(Layout argument, Layout variable, Layout lowerB, Layout upperB) { return TreeHandle::FixedArityBuilder<SumLayout,SumLayoutNode>(ArrayBuilder<TreeHandle>(argument, variable, lowerB, upperB).array(), 4); }
static SumLayout Builder(Layout argument, Layout variable, Layout lowerB, Layout upperB) { return TreeHandle::FixedArityBuilder<SumLayout,SumLayoutNode>({argument, variable, lowerB, upperB}); }
SumLayout() = delete;
};

2
poincare/include/poincare/tangent.h
View File

@@ -45,7 +45,7 @@ private:
class Tangent final : public Expression {
public:
Tangent(const TangentNode * n) : Expression(n) {}
static Tangent Builder(Expression child) { return TreeHandle::FixedArityBuilder<Tangent, TangentNode>(&child, 1); }
static Tangent Builder(Expression child) { return TreeHandle::FixedArityBuilder<Tangent, TangentNode>({child}); }
static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("tan", 1, &UntypedBuilderOneChild<Tangent>);

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

@@ -2,7 +2,7 @@
#define POINCARE_TREE_BY_REFERENCE_H
#include <poincare/tree_pool.h>
#include <stdio.h>
#include <initializer_list>
namespace Shared {
class ContinuousFunction;
@@ -23,8 +23,6 @@ namespace Poincare {
* equivalent to Logarithm l = Logarithm(clone())). */
class TreeHandle {
template<class T>
friend class ArrayBuilder;
friend class ::Shared::ContinuousFunction;
friend class TreeNode;
friend class TreePool;
@@ -107,6 +105,8 @@ public:
void log() const;
#endif
typedef std::initializer_list<TreeHandle> Tuple;
protected:
/* Constructor */
TreeHandle(const TreeNode * node);
@@ -119,9 +119,9 @@ protected:
// WARNING: if the children table is the result of a cast, the object downcasted has to be the same size as a TreeHandle.
template <class T, class U>
static T NAryBuilder(TreeHandle * children = nullptr, size_t numberOfChildren = 0);
static T NAryBuilder(const Tuple & children = {});
template <class T, class U>
static T FixedArityBuilder(TreeHandle * children = nullptr, size_t numberOfChildren = 0);
static T FixedArityBuilder(const Tuple & children = {});
static TreeHandle BuildWithGhostChildren(TreeNode * node);

2
poincare/include/poincare/unit_convert.h
View File

@@ -33,7 +33,7 @@ class UnitConvert final : public Expression {
friend class UnitConvertNode;
public:
UnitConvert(const UnitConvertNode * n) : Expression(n) {}
static UnitConvert Builder(Expression value, Expression unit) { return TreeHandle::FixedArityBuilder<UnitConvert, UnitConvertNode>(ArrayBuilder<TreeHandle>(value, unit).array(), 2); }
static UnitConvert Builder(Expression value, Expression unit) { return TreeHandle::FixedArityBuilder<UnitConvert, UnitConvertNode>({value, unit}); }
// Expression
Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);

12
poincare/src/matrix.cpp
View File

@@ -378,17 +378,17 @@ Expression Matrix::determinant(ExpressionNode::ReductionContext reductionContext
Expression g = m.matrixChild(2,0);
Expression h = m.matrixChild(2,1);
Expression i = m.matrixChild(2,2);
constexpr int additionChildrenCount = 6;
Expression additionChildren[additionChildrenCount] = {
Tuple children = {
Multiplication::Builder(a.clone(), e.clone(), i.clone()),
Multiplication::Builder(b.clone(), f.clone(), g.clone()),
Multiplication::Builder(c.clone(), d.clone(), h.clone()),
Multiplication::Builder(Rational::Builder(-1), c, e, g),
Multiplication::Builder(Rational::Builder(-1), b, d, i),
Multiplication::Builder(Rational::Builder(-1), a, f, h)};
Expression result = Addition::Builder(additionChildren, additionChildrenCount);
for (int i = 0; i < additionChildrenCount; i++) {
additionChildren[i].shallowReduce(reductionContext);
Multiplication::Builder(Rational::Builder(-1), a, f, h)
};
Expression result = Addition::Builder(children);
for (Expression child : children) {
child.shallowReduce(reductionContext);
}
return result;
}

2
poincare/src/matrix_layout.cpp
View File

@@ -331,7 +331,7 @@ void MatrixLayoutNode::didReplaceChildAtIndex(int index, LayoutCursor * cursor,
}
MatrixLayout MatrixLayout::Builder(Layout l1, Layout l2, Layout l3, Layout l4) {
MatrixLayout m = TreeHandle::NAryBuilder<MatrixLayout, MatrixLayoutNode>(ArrayBuilder<TreeHandle>(l1,l2,l3,l4).array(), 4);
MatrixLayout m = TreeHandle::NAryBuilder<MatrixLayout, MatrixLayoutNode>({l1, l2, l3, l4});
m.setDimensions(2, 2);
return m;
}

197
poincare/src/tree_handle.cpp
View File

@@ -212,19 +212,22 @@ TreeHandle TreeHandle::Builder() {
}
template <class T, class U>
T TreeHandle::NAryBuilder(TreeHandle * children, size_t numberOfChildren) {
T TreeHandle::NAryBuilder(const Tuple & children) {
TreeHandle h = Builder<U>();
for (size_t i = 0; i < numberOfChildren; i++) {
h.addChildAtIndexInPlace(children[i], i, i);
size_t i = 0;
for (TreeHandle child : children) {
h.addChildAtIndexInPlace(child, i, i);
i++;
}
return static_cast<T &>(h);
}
template <class T, class U>
T TreeHandle::FixedArityBuilder(TreeHandle * children, size_t numberOfChildren) {
T TreeHandle::FixedArityBuilder(const Tuple & children) {
TreeHandle h = Builder<U>();
for (size_t i = 0; i < numberOfChildren; i++) {
h.replaceChildAtIndexInPlace(i, children[i]);
size_t i = 0;
for (TreeHandle child : children) {
h.replaceChildAtIndexInPlace(i++, child);
}
return static_cast<T &>(h);
}
@@ -277,96 +280,96 @@ void TreeHandle::release(uint16_t identifier) {
node->release(node->numberOfChildren());
}
template AbsoluteValue TreeHandle::FixedArityBuilder<AbsoluteValue, AbsoluteValueNode>(TreeHandle*, size_t);
template AbsoluteValueLayout TreeHandle::FixedArityBuilder<AbsoluteValueLayout, AbsoluteValueLayoutNode>(TreeHandle*, size_t);
template Addition TreeHandle::NAryBuilder<Addition, AdditionNode>(TreeHandle*, size_t);
template ArcCosine TreeHandle::FixedArityBuilder<ArcCosine, ArcCosineNode>(TreeHandle*, size_t);
template ArcSine TreeHandle::FixedArityBuilder<ArcSine, ArcSineNode>(TreeHandle*, size_t);
template ArcTangent TreeHandle::FixedArityBuilder<ArcTangent, ArcTangentNode>(TreeHandle*, size_t);
template BinomCDF TreeHandle::FixedArityBuilder<BinomCDF, BinomCDFNode>(TreeHandle*, size_t);
template BinomialCoefficient TreeHandle::FixedArityBuilder<BinomialCoefficient, BinomialCoefficientNode>(TreeHandle*, size_t);
template BinomialCoefficientLayout TreeHandle::FixedArityBuilder<BinomialCoefficientLayout, BinomialCoefficientLayoutNode>(TreeHandle*, size_t);
template BinomPDF TreeHandle::FixedArityBuilder<BinomPDF, BinomPDFNode>(TreeHandle*, size_t);
template Ceiling TreeHandle::FixedArityBuilder<Ceiling, CeilingNode>(TreeHandle*, size_t);
template CeilingLayout TreeHandle::FixedArityBuilder<CeilingLayout, CeilingLayoutNode>(TreeHandle*, size_t);
template CommonLogarithm TreeHandle::FixedArityBuilder<CommonLogarithm, LogarithmNode<1> >(TreeHandle*, size_t);
template ComplexArgument TreeHandle::FixedArityBuilder<ComplexArgument, ComplexArgumentNode>(TreeHandle*, size_t);
template ComplexCartesian TreeHandle::FixedArityBuilder<ComplexCartesian, ComplexCartesianNode>(TreeHandle*, size_t);
template CondensedSumLayout TreeHandle::FixedArityBuilder<CondensedSumLayout, CondensedSumLayoutNode>(TreeHandle*, size_t);
template ConfidenceInterval TreeHandle::FixedArityBuilder<ConfidenceInterval, ConfidenceIntervalNode>(TreeHandle*, size_t);
template Conjugate TreeHandle::FixedArityBuilder<Conjugate, ConjugateNode>(TreeHandle*, size_t);
template ConjugateLayout TreeHandle::FixedArityBuilder<ConjugateLayout, ConjugateLayoutNode>(TreeHandle*, size_t);
template Cosine TreeHandle::FixedArityBuilder<Cosine, CosineNode>(TreeHandle*, size_t);
template Derivative TreeHandle::FixedArityBuilder<Derivative, DerivativeNode>(TreeHandle*, size_t);
template Determinant TreeHandle::FixedArityBuilder<Determinant, DeterminantNode>(TreeHandle*, size_t);
template Division TreeHandle::FixedArityBuilder<Division, DivisionNode>(TreeHandle*, size_t);
template DivisionQuotient TreeHandle::FixedArityBuilder<DivisionQuotient, DivisionQuotientNode>(TreeHandle*, size_t);
template DivisionRemainder TreeHandle::FixedArityBuilder<DivisionRemainder, DivisionRemainderNode>(TreeHandle*, size_t);
template EmptyExpression TreeHandle::FixedArityBuilder<EmptyExpression, EmptyExpressionNode>(TreeHandle*, size_t);
template Equal TreeHandle::FixedArityBuilder<Equal, EqualNode>(TreeHandle*, size_t);
template Factor TreeHandle::FixedArityBuilder<Factor, FactorNode>(TreeHandle*, size_t);
template Factorial TreeHandle::FixedArityBuilder<Factorial, FactorialNode>(TreeHandle*, size_t);
template Floor TreeHandle::FixedArityBuilder<Floor, FloorNode>(TreeHandle*, size_t);
template FloorLayout TreeHandle::FixedArityBuilder<FloorLayout, FloorLayoutNode>(TreeHandle*, size_t);
template FracPart TreeHandle::FixedArityBuilder<FracPart, FracPartNode>(TreeHandle*, size_t);
template FractionLayout TreeHandle::FixedArityBuilder<FractionLayout, FractionLayoutNode>(TreeHandle*, size_t);
template Ghost TreeHandle::FixedArityBuilder<Ghost, GhostNode>(TreeHandle*, size_t);
template GreatCommonDivisor TreeHandle::FixedArityBuilder<GreatCommonDivisor, GreatCommonDivisorNode>(TreeHandle*, size_t);
template HorizontalLayout TreeHandle::NAryBuilder<HorizontalLayout, HorizontalLayoutNode>(TreeHandle*, size_t);
template HyperbolicArcCosine TreeHandle::FixedArityBuilder<HyperbolicArcCosine, HyperbolicArcCosineNode>(TreeHandle*, size_t);
template HyperbolicArcSine TreeHandle::FixedArityBuilder<HyperbolicArcSine, HyperbolicArcSineNode>(TreeHandle*, size_t);
template HyperbolicArcTangent TreeHandle::FixedArityBuilder<HyperbolicArcTangent, HyperbolicArcTangentNode>(TreeHandle*, size_t);
template HyperbolicCosine TreeHandle::FixedArityBuilder<HyperbolicCosine, HyperbolicCosineNode>(TreeHandle*, size_t);
template HyperbolicSine TreeHandle::FixedArityBuilder<HyperbolicSine, HyperbolicSineNode>(TreeHandle*, size_t);
template HyperbolicTangent TreeHandle::FixedArityBuilder<HyperbolicTangent, HyperbolicTangentNode>(TreeHandle*, size_t);
template ImaginaryPart TreeHandle::FixedArityBuilder<ImaginaryPart, ImaginaryPartNode>(TreeHandle*, size_t);
template Integral TreeHandle::FixedArityBuilder<Integral, IntegralNode>(TreeHandle*, size_t);
template IntegralLayout TreeHandle::FixedArityBuilder<IntegralLayout, IntegralLayoutNode>(TreeHandle*, size_t);
template InvBinom TreeHandle::FixedArityBuilder<InvBinom, InvBinomNode>(TreeHandle*, size_t);
template InvNorm TreeHandle::FixedArityBuilder<InvNorm, InvNormNode>(TreeHandle*, size_t);
template LeastCommonMultiple TreeHandle::FixedArityBuilder<LeastCommonMultiple, LeastCommonMultipleNode>(TreeHandle*, size_t);
template LeftParenthesisLayout TreeHandle::FixedArityBuilder<LeftParenthesisLayout, LeftParenthesisLayoutNode>(TreeHandle*, size_t);
template LeftSquareBracketLayout TreeHandle::FixedArityBuilder<LeftSquareBracketLayout, LeftSquareBracketLayoutNode>(TreeHandle*, size_t);
template Logarithm TreeHandle::FixedArityBuilder<Logarithm, LogarithmNode<2> >(TreeHandle*, size_t);
template Matrix TreeHandle::NAryBuilder<Matrix, MatrixNode>(TreeHandle*, size_t);
template MatrixComplex<double> TreeHandle::NAryBuilder<MatrixComplex<double>, MatrixComplexNode<double> >(TreeHandle*, size_t);
template MatrixComplex<float> TreeHandle::NAryBuilder<MatrixComplex<float>, MatrixComplexNode<float> >(TreeHandle*, size_t);
template MatrixDimension TreeHandle::FixedArityBuilder<MatrixDimension, MatrixDimensionNode>(TreeHandle*, size_t);
template MatrixIdentity TreeHandle::FixedArityBuilder<MatrixIdentity, MatrixIdentityNode>(TreeHandle*, size_t);
template MatrixInverse TreeHandle::FixedArityBuilder<MatrixInverse, MatrixInverseNode>(TreeHandle*, size_t);
template MatrixTrace TreeHandle::FixedArityBuilder<MatrixTrace, MatrixTraceNode>(TreeHandle*, size_t);
template MatrixTranspose TreeHandle::FixedArityBuilder<MatrixTranspose, MatrixTransposeNode>(TreeHandle*, size_t);
template Multiplication TreeHandle::NAryBuilder<Multiplication, MultiplicationNode>(TreeHandle*, size_t);
template NaperianLogarithm TreeHandle::FixedArityBuilder<NaperianLogarithm, NaperianLogarithmNode>(TreeHandle*, size_t);
template NormCDF TreeHandle::FixedArityBuilder<NormCDF, NormCDFNode>(TreeHandle*, size_t);
template NormCDF2 TreeHandle::FixedArityBuilder<NormCDF2, NormCDF2Node>(TreeHandle*, size_t);
template NormPDF TreeHandle::FixedArityBuilder<NormPDF, NormPDFNode>(TreeHandle*, size_t);
template NthRoot TreeHandle::FixedArityBuilder<NthRoot, NthRootNode>(TreeHandle*, size_t);
template Opposite TreeHandle::FixedArityBuilder<Opposite, OppositeNode>(TreeHandle*, size_t);
template Parenthesis TreeHandle::FixedArityBuilder<Parenthesis, ParenthesisNode>(TreeHandle*, size_t);
template PermuteCoefficient TreeHandle::FixedArityBuilder<PermuteCoefficient, PermuteCoefficientNode>(TreeHandle*, size_t);
template Power TreeHandle::FixedArityBuilder<Power, PowerNode>(TreeHandle*, size_t);
template PredictionInterval TreeHandle::FixedArityBuilder<PredictionInterval, PredictionIntervalNode>(TreeHandle*, size_t);
template Product TreeHandle::FixedArityBuilder<Product, ProductNode>(TreeHandle*, size_t);
template ProductLayout TreeHandle::FixedArityBuilder<ProductLayout, ProductLayoutNode>(TreeHandle*, size_t);
template Randint TreeHandle::FixedArityBuilder<Randint, RandintNode>(TreeHandle*, size_t);
template Random TreeHandle::FixedArityBuilder<Random, RandomNode>(TreeHandle*, size_t);
template RealPart TreeHandle::FixedArityBuilder<RealPart, RealPartNode>(TreeHandle*, size_t);
template RightParenthesisLayout TreeHandle::FixedArityBuilder<RightParenthesisLayout, RightParenthesisLayoutNode>(TreeHandle*, size_t);
template RightSquareBracketLayout TreeHandle::FixedArityBuilder<RightSquareBracketLayout, RightSquareBracketLayoutNode>(TreeHandle*, size_t);
template Round TreeHandle::FixedArityBuilder<Round, RoundNode>(TreeHandle*, size_t);
template SignFunction TreeHandle::FixedArityBuilder<SignFunction, SignFunctionNode>(TreeHandle*, size_t);
template SimplePredictionInterval TreeHandle::FixedArityBuilder<SimplePredictionInterval, SimplePredictionIntervalNode>(TreeHandle*, size_t);
template Sine TreeHandle::FixedArityBuilder<Sine, SineNode>(TreeHandle*, size_t);
template SquareRoot TreeHandle::FixedArityBuilder<SquareRoot, SquareRootNode>(TreeHandle*, size_t);
template Store TreeHandle::FixedArityBuilder<Store, StoreNode>(TreeHandle*, size_t);
template Subtraction TreeHandle::FixedArityBuilder<Subtraction, SubtractionNode>(TreeHandle*, size_t);
template Sum TreeHandle::FixedArityBuilder<Sum, SumNode>(TreeHandle*, size_t);
template SumLayout TreeHandle::FixedArityBuilder<SumLayout, SumLayoutNode>(TreeHandle*, size_t);
template Tangent TreeHandle::FixedArityBuilder<Tangent, TangentNode>(TreeHandle*, size_t);
template Undefined TreeHandle::FixedArityBuilder<Undefined, UndefinedNode>(TreeHandle*, size_t);
template UnitConvert TreeHandle::FixedArityBuilder<UnitConvert, UnitConvertNode>(TreeHandle*, size_t);
template Unreal TreeHandle::FixedArityBuilder<Unreal, UnrealNode>(TreeHandle*, size_t);
template MatrixLayout TreeHandle::NAryBuilder<MatrixLayout, MatrixLayoutNode>(TreeHandle*, size_t);
template AbsoluteValue TreeHandle::FixedArityBuilder<AbsoluteValue, AbsoluteValueNode>(const Tuple &);
template AbsoluteValueLayout TreeHandle::FixedArityBuilder<AbsoluteValueLayout, AbsoluteValueLayoutNode>(const Tuple &);
template Addition TreeHandle::NAryBuilder<Addition, AdditionNode>(const Tuple &);
template ArcCosine TreeHandle::FixedArityBuilder<ArcCosine, ArcCosineNode>(const Tuple &);
template ArcSine TreeHandle::FixedArityBuilder<ArcSine, ArcSineNode>(const Tuple &);
template ArcTangent TreeHandle::FixedArityBuilder<ArcTangent, ArcTangentNode>(const Tuple &);
template BinomCDF TreeHandle::FixedArityBuilder<BinomCDF, BinomCDFNode>(const Tuple &);
template BinomialCoefficient TreeHandle::FixedArityBuilder<BinomialCoefficient, BinomialCoefficientNode>(const Tuple &);
template BinomialCoefficientLayout TreeHandle::FixedArityBuilder<BinomialCoefficientLayout, BinomialCoefficientLayoutNode>(const Tuple &);
template BinomPDF TreeHandle::FixedArityBuilder<BinomPDF, BinomPDFNode>(const Tuple &);
template Ceiling TreeHandle::FixedArityBuilder<Ceiling, CeilingNode>(const Tuple &);
template CeilingLayout TreeHandle::FixedArityBuilder<CeilingLayout, CeilingLayoutNode>(const Tuple &);
template CommonLogarithm TreeHandle::FixedArityBuilder<CommonLogarithm, LogarithmNode<1> >(const Tuple &);
template ComplexArgument TreeHandle::FixedArityBuilder<ComplexArgument, ComplexArgumentNode>(const Tuple &);
template ComplexCartesian TreeHandle::FixedArityBuilder<ComplexCartesian, ComplexCartesianNode>(const Tuple &);
template CondensedSumLayout TreeHandle::FixedArityBuilder<CondensedSumLayout, CondensedSumLayoutNode>(const Tuple &);
template ConfidenceInterval TreeHandle::FixedArityBuilder<ConfidenceInterval, ConfidenceIntervalNode>(const Tuple &);
template Conjugate TreeHandle::FixedArityBuilder<Conjugate, ConjugateNode>(const Tuple &);
template ConjugateLayout TreeHandle::FixedArityBuilder<ConjugateLayout, ConjugateLayoutNode>(const Tuple &);
template Cosine TreeHandle::FixedArityBuilder<Cosine, CosineNode>(const Tuple &);
template Derivative TreeHandle::FixedArityBuilder<Derivative, DerivativeNode>(const Tuple &);
template Determinant TreeHandle::FixedArityBuilder<Determinant, DeterminantNode>(const Tuple &);
template Division TreeHandle::FixedArityBuilder<Division, DivisionNode>(const Tuple &);
template DivisionQuotient TreeHandle::FixedArityBuilder<DivisionQuotient, DivisionQuotientNode>(const Tuple &);
template DivisionRemainder TreeHandle::FixedArityBuilder<DivisionRemainder, DivisionRemainderNode>(const Tuple &);
template EmptyExpression TreeHandle::FixedArityBuilder<EmptyExpression, EmptyExpressionNode>(const Tuple &);
template Equal TreeHandle::FixedArityBuilder<Equal, EqualNode>(const Tuple &);
template Factor TreeHandle::FixedArityBuilder<Factor, FactorNode>(const Tuple &);
template Factorial TreeHandle::FixedArityBuilder<Factorial, FactorialNode>(const Tuple &);
template Floor TreeHandle::FixedArityBuilder<Floor, FloorNode>(const Tuple &);
template FloorLayout TreeHandle::FixedArityBuilder<FloorLayout, FloorLayoutNode>(const Tuple &);
template FracPart TreeHandle::FixedArityBuilder<FracPart, FracPartNode>(const Tuple &);
template FractionLayout TreeHandle::FixedArityBuilder<FractionLayout, FractionLayoutNode>(const Tuple &);
template Ghost TreeHandle::FixedArityBuilder<Ghost, GhostNode>(const Tuple &);
template GreatCommonDivisor TreeHandle::FixedArityBuilder<GreatCommonDivisor, GreatCommonDivisorNode>(const Tuple &);
template HorizontalLayout TreeHandle::NAryBuilder<HorizontalLayout, HorizontalLayoutNode>(const Tuple &);
template HyperbolicArcCosine TreeHandle::FixedArityBuilder<HyperbolicArcCosine, HyperbolicArcCosineNode>(const Tuple &);
template HyperbolicArcSine TreeHandle::FixedArityBuilder<HyperbolicArcSine, HyperbolicArcSineNode>(const Tuple &);
template HyperbolicArcTangent TreeHandle::FixedArityBuilder<HyperbolicArcTangent, HyperbolicArcTangentNode>(const Tuple &);
template HyperbolicCosine TreeHandle::FixedArityBuilder<HyperbolicCosine, HyperbolicCosineNode>(const Tuple &);
template HyperbolicSine TreeHandle::FixedArityBuilder<HyperbolicSine, HyperbolicSineNode>(const Tuple &);
template HyperbolicTangent TreeHandle::FixedArityBuilder<HyperbolicTangent, HyperbolicTangentNode>(const Tuple &);
template ImaginaryPart TreeHandle::FixedArityBuilder<ImaginaryPart, ImaginaryPartNode>(const Tuple &);
template Integral TreeHandle::FixedArityBuilder<Integral, IntegralNode>(const Tuple &);
template IntegralLayout TreeHandle::FixedArityBuilder<IntegralLayout, IntegralLayoutNode>(const Tuple &);
template InvBinom TreeHandle::FixedArityBuilder<InvBinom, InvBinomNode>(const Tuple &);
template InvNorm TreeHandle::FixedArityBuilder<InvNorm, InvNormNode>(const Tuple &);
template LeastCommonMultiple TreeHandle::FixedArityBuilder<LeastCommonMultiple, LeastCommonMultipleNode>(const Tuple &);
template LeftParenthesisLayout TreeHandle::FixedArityBuilder<LeftParenthesisLayout, LeftParenthesisLayoutNode>(const Tuple &);
template LeftSquareBracketLayout TreeHandle::FixedArityBuilder<LeftSquareBracketLayout, LeftSquareBracketLayoutNode>(const Tuple &);
template Logarithm TreeHandle::FixedArityBuilder<Logarithm, LogarithmNode<2> >(const Tuple &);
template Matrix TreeHandle::NAryBuilder<Matrix, MatrixNode>(const Tuple &);
template MatrixComplex<double> TreeHandle::NAryBuilder<MatrixComplex<double>, MatrixComplexNode<double> >(const Tuple &);
template MatrixComplex<float> TreeHandle::NAryBuilder<MatrixComplex<float>, MatrixComplexNode<float> >(const Tuple &);
template MatrixDimension TreeHandle::FixedArityBuilder<MatrixDimension, MatrixDimensionNode>(const Tuple &);
template MatrixIdentity TreeHandle::FixedArityBuilder<MatrixIdentity, MatrixIdentityNode>(const Tuple &);
template MatrixInverse TreeHandle::FixedArityBuilder<MatrixInverse, MatrixInverseNode>(const Tuple &);
template MatrixTrace TreeHandle::FixedArityBuilder<MatrixTrace, MatrixTraceNode>(const Tuple &);
template MatrixTranspose TreeHandle::FixedArityBuilder<MatrixTranspose, MatrixTransposeNode>(const Tuple &);
template Multiplication TreeHandle::NAryBuilder<Multiplication, MultiplicationNode>(const Tuple &);
template NaperianLogarithm TreeHandle::FixedArityBuilder<NaperianLogarithm, NaperianLogarithmNode>(const Tuple &);
template NormCDF TreeHandle::FixedArityBuilder<NormCDF, NormCDFNode>(const Tuple &);
template NormCDF2 TreeHandle::FixedArityBuilder<NormCDF2, NormCDF2Node>(const Tuple &);
template NormPDF TreeHandle::FixedArityBuilder<NormPDF, NormPDFNode>(const Tuple &);
template NthRoot TreeHandle::FixedArityBuilder<NthRoot, NthRootNode>(const Tuple &);
template Opposite TreeHandle::FixedArityBuilder<Opposite, OppositeNode>(const Tuple &);
template Parenthesis TreeHandle::FixedArityBuilder<Parenthesis, ParenthesisNode>(const Tuple &);
template PermuteCoefficient TreeHandle::FixedArityBuilder<PermuteCoefficient, PermuteCoefficientNode>(const Tuple &);
template Power TreeHandle::FixedArityBuilder<Power, PowerNode>(const Tuple &);
template PredictionInterval TreeHandle::FixedArityBuilder<PredictionInterval, PredictionIntervalNode>(const Tuple &);
template Product TreeHandle::FixedArityBuilder<Product, ProductNode>(const Tuple &);
template ProductLayout TreeHandle::FixedArityBuilder<ProductLayout, ProductLayoutNode>(const Tuple &);
template Randint TreeHandle::FixedArityBuilder<Randint, RandintNode>(const Tuple &);
template Random TreeHandle::FixedArityBuilder<Random, RandomNode>(const Tuple &);
template RealPart TreeHandle::FixedArityBuilder<RealPart, RealPartNode>(const Tuple &);
template RightParenthesisLayout TreeHandle::FixedArityBuilder<RightParenthesisLayout, RightParenthesisLayoutNode>(const Tuple &);
template RightSquareBracketLayout TreeHandle::FixedArityBuilder<RightSquareBracketLayout, RightSquareBracketLayoutNode>(const Tuple &);
template Round TreeHandle::FixedArityBuilder<Round, RoundNode>(const Tuple &);
template SignFunction TreeHandle::FixedArityBuilder<SignFunction, SignFunctionNode>(const Tuple &);
template SimplePredictionInterval TreeHandle::FixedArityBuilder<SimplePredictionInterval, SimplePredictionIntervalNode>(const Tuple &);
template Sine TreeHandle::FixedArityBuilder<Sine, SineNode>(const Tuple &);
template SquareRoot TreeHandle::FixedArityBuilder<SquareRoot, SquareRootNode>(const Tuple &);
template Store TreeHandle::FixedArityBuilder<Store, StoreNode>(const Tuple &);
template Subtraction TreeHandle::FixedArityBuilder<Subtraction, SubtractionNode>(const Tuple &);
template Sum TreeHandle::FixedArityBuilder<Sum, SumNode>(const Tuple &);
template SumLayout TreeHandle::FixedArityBuilder<SumLayout, SumLayoutNode>(const Tuple &);
template Tangent TreeHandle::FixedArityBuilder<Tangent, TangentNode>(const Tuple &);
template Undefined TreeHandle::FixedArityBuilder<Undefined, UndefinedNode>(const Tuple &);
template UnitConvert TreeHandle::FixedArityBuilder<UnitConvert, UnitConvertNode>(const Tuple &);
template Unreal TreeHandle::FixedArityBuilder<Unreal, UnrealNode>(const Tuple &);
template MatrixLayout TreeHandle::NAryBuilder<MatrixLayout, MatrixLayoutNode>(const Tuple &);
}

46
poincare/test/expression_order.cpp
View File

@@ -98,11 +98,16 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
}
{
// 1 + 2 + 0 -> 2 + 1 + 0
constexpr int numberOfChildren = 3;
Expression children[numberOfChildren] = {Rational::Builder(1), Rational::Builder(2), Rational::Builder(0)};
Expression childrenSorted[numberOfChildren] = {Rational::Builder(2), Rational::Builder(1), Rational::Builder(0)};
Expression e1 = Addition::Builder(children, numberOfChildren);
Expression e2 = Addition::Builder(childrenSorted, numberOfChildren);
Expression e1 = Addition::Builder({
Rational::Builder(1),
Rational::Builder(2),
Rational::Builder(0)
});
Expression e2 = Addition::Builder({
Rational::Builder(2),
Rational::Builder(1),
Rational::Builder(0)
});
assert_multiplication_or_addition_is_ordered_as(e1, e2);
}
{
@@ -110,11 +115,8 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
Expression pi = Constant::Builder(UCodePointGreekSmallLetterPi);
Expression i = Constant::Builder(UCodePointMathematicalBoldSmallI);
Expression e = Constant::Builder(UCodePointScriptSmallE);
constexpr int numberOfChildren = 3;
Expression children[numberOfChildren] = {pi.clone(), i.clone(), e.clone()};
Expression childrenSorted[numberOfChildren] = {e, pi, i};
Expression e1 = Addition::Builder(children, numberOfChildren);
Expression e2 = Addition::Builder(childrenSorted, numberOfChildren);
Expression e1 = Addition::Builder({pi.clone(), i.clone(), e.clone()});
Expression e2 = Addition::Builder({e, pi, i});
assert_multiplication_or_addition_is_ordered_as(e1, e2);
}
{
@@ -124,22 +126,19 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
assert_multiplication_or_addition_is_ordered_as(e1, e2);
}
{
constexpr int numberOfChildren = 4;
Expression children[numberOfChildren] = {
// c + b^2 + a^2 + a -> a^2 + a + b^2 + c
Expression e1 = Addition::Builder({
Symbol::Builder('c'),
Power::Builder(Symbol::Builder('b'), Rational::Builder(2)),
Power::Builder(Symbol::Builder('a'), Rational::Builder(2)),
Symbol::Builder('a')
};
Expression childrenSorted[numberOfChildren] = {
});
Expression e2 = Addition::Builder({
Power::Builder(Symbol::Builder('a'), Rational::Builder(2)),
Symbol::Builder('a'),
Power::Builder(Symbol::Builder('b'), Rational::Builder(2)),
Symbol::Builder('c')
};
// c + b^2 + a^2 + a -> a^2 + a + b^2 + c
Expression e1 = Addition::Builder(children, numberOfChildren);
Expression e2 = Addition::Builder(childrenSorted, numberOfChildren);
});
assert_multiplication_or_addition_is_ordered_as(e1, e2);
}
{
@@ -194,21 +193,18 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
Expression childMatrix2 = Matrix::Builder();
static_cast<Matrix &>(childMatrix2).addChildAtIndexInPlace(Rational::Builder(0), 0, 0);
constexpr int numberOfChildren = 4;
Expression children[numberOfChildren] = {
Expression e1 = Multiplication::Builder({
child2.clone(),
childMatrix1.clone(),
childMatrix2.clone(),
child1.clone()
};
Expression childrenSorted[numberOfChildren] = {
});
Expression e2 = Multiplication::Builder({
child1.clone(),
child2.clone(),
childMatrix1.clone(),
childMatrix2.clone()
};
Expression e1 = Multiplication::Builder(children, numberOfChildren);
Expression e2 = Multiplication::Builder(childrenSorted, numberOfChildren);
});
assert_multiplication_or_addition_is_ordered_as(e1, e2);
}

268
poincare/test/layout_to_expression.cpp
View File

@@ -43,19 +43,18 @@ QUIZ_CASE(poincare_layout_to_expression_unparsable) {
* ∑ (5)
* n=1
*/
constexpr int childrenCount = 5;
Layout children[childrenCount] = {
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder('+'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('1')};
Layout l = SumLayout::Builder(
CodePointLayout::Builder('5'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('1'),
HorizontalLayout::Builder(children, childrenCount));
CodePointLayout::Builder('5'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('1'),
HorizontalLayout::Builder({
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder('+'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('1')
})
);
assert_layout_is_not_parsed(l);
}
@@ -64,34 +63,30 @@ QUIZ_CASE(poincare_layout_to_expression_unparsable) {
* π (5)
* n=1+binomial(3
*/
constexpr int children1Count = 12;
Layout children1[children1Count] = {
CodePointLayout::Builder('1'),
CodePointLayout::Builder('+'),
CodePointLayout::Builder('b'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('o'),
CodePointLayout::Builder('m'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('a'),
CodePointLayout::Builder('l'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('3')};
constexpr int children2Count = 4;
Layout children2[children2Count] = {
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder(','),
CodePointLayout::Builder('1')};
Layout l = SumLayout::Builder(
CodePointLayout::Builder('5'),
CodePointLayout::Builder('5'),
CodePointLayout::Builder('n'),
HorizontalLayout::Builder({
CodePointLayout::Builder('1'),
CodePointLayout::Builder('+'),
CodePointLayout::Builder('b'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('n'),
HorizontalLayout::Builder(children1, children1Count),
HorizontalLayout::Builder(children2, children2Count));
CodePointLayout::Builder('o'),
CodePointLayout::Builder('m'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('a'),
CodePointLayout::Builder('l'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('3')
}),
HorizontalLayout::Builder({
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder(','),
CodePointLayout::Builder('1')
})
);
assert_layout_is_not_parsed(l);
}
@@ -100,19 +95,18 @@ QUIZ_CASE(poincare_layout_to_expression_unparsable) {
* π (5)
* n=1
*/
constexpr int childrenCount = 5;
Layout children[childrenCount] = {
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder('+'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('1')};
Layout l = ProductLayout::Builder(
CodePointLayout::Builder('5'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('1'),
HorizontalLayout::Builder(children, childrenCount));
CodePointLayout::Builder('5'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('1'),
HorizontalLayout::Builder({
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder('+'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('1')
})
);
assert_layout_is_not_parsed(l);
}
@@ -121,34 +115,30 @@ QUIZ_CASE(poincare_layout_to_expression_unparsable) {
* π (5)
* n=1+binomial(3
*/
constexpr int children1Count = 12;
Layout children1[children1Count] = {
CodePointLayout::Builder('1'),
CodePointLayout::Builder('+'),
CodePointLayout::Builder('b'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('o'),
CodePointLayout::Builder('m'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('a'),
CodePointLayout::Builder('l'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('3')};
constexpr int children2Count = 4;
Layout children2[children2Count] = {
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder(','),
CodePointLayout::Builder('1')};
Layout l = ProductLayout::Builder(
CodePointLayout::Builder('5'),
CodePointLayout::Builder('5'),
CodePointLayout::Builder('n'),
HorizontalLayout::Builder({
CodePointLayout::Builder('1'),
CodePointLayout::Builder('+'),
CodePointLayout::Builder('b'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('n'),
HorizontalLayout::Builder(children1, children1Count),
HorizontalLayout::Builder(children2, children2Count));
CodePointLayout::Builder('o'),
CodePointLayout::Builder('m'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('a'),
CodePointLayout::Builder('l'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('3')
}),
HorizontalLayout::Builder({
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder(','),
CodePointLayout::Builder('1')
})
);
assert_layout_is_not_parsed(l);
}
@@ -157,19 +147,18 @@ QUIZ_CASE(poincare_layout_to_expression_unparsable) {
* ∫ (5)dx
* 1
*/
constexpr int childrenCount = 5;
Layout children[childrenCount] = {
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder('+'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('1')};
Layout l = IntegralLayout::Builder(
CodePointLayout::Builder('5'),
CodePointLayout::Builder('x'),
CodePointLayout::Builder('1'),
HorizontalLayout::Builder(children, childrenCount));
CodePointLayout::Builder('5'),
CodePointLayout::Builder('x'),
CodePointLayout::Builder('1'),
HorizontalLayout::Builder({
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder('+'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('1')
})
);
assert_layout_is_not_parsed(l);
}
@@ -178,48 +167,42 @@ QUIZ_CASE(poincare_layout_to_expression_unparsable) {
* ∫ (5)dx
* 1+binomial(3
*/
constexpr int children1Count = 12;
Layout children1[children1Count] = {
CodePointLayout::Builder('1'),
CodePointLayout::Builder('+'),
CodePointLayout::Builder('b'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('o'),
CodePointLayout::Builder('m'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('a'),
CodePointLayout::Builder('l'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('3')};
constexpr int children2Count = 4;
Layout children2[children2Count] = {
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder(','),
CodePointLayout::Builder('1')};
Layout l = IntegralLayout::Builder(
CodePointLayout::Builder('5'),
CodePointLayout::Builder('x'),
HorizontalLayout::Builder(children1, children1Count),
HorizontalLayout::Builder(children2, children2Count));
CodePointLayout::Builder('5'),
CodePointLayout::Builder('x'),
HorizontalLayout::Builder({
CodePointLayout::Builder('1'),
CodePointLayout::Builder('+'),
CodePointLayout::Builder('b'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('o'),
CodePointLayout::Builder('m'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('a'),
CodePointLayout::Builder('l'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('3')
}),
HorizontalLayout::Builder({
CodePointLayout::Builder('2'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder(','),
CodePointLayout::Builder('1')
})
);
assert_layout_is_not_parsed(l);
}
{
// |3)+(1|
constexpr int childrenCount = 5;
Layout children[childrenCount] = {
Layout l = AbsoluteValueLayout::Builder(HorizontalLayout::Builder({
CodePointLayout::Builder('3'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder('+'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('1')};
Layout l = AbsoluteValueLayout::Builder(HorizontalLayout::Builder(children, childrenCount));
CodePointLayout::Builder('1')
}));
assert_layout_is_not_parsed(l);
}
@@ -229,31 +212,28 @@ QUIZ_CASE(poincare_layout_to_expression_unparsable) {
* | 1),1 |
* \ /
*/
constexpr int children1Count = 12;
Layout children1[children1Count] = {
CodePointLayout::Builder('1'),
CodePointLayout::Builder('+'),
CodePointLayout::Builder('b'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('o'),
CodePointLayout::Builder('m'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('a'),
CodePointLayout::Builder('l'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('3')};
constexpr int children2Count = 4;
Layout children2[children2Count] = {
CodePointLayout::Builder('1'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder(','),
CodePointLayout::Builder('1')};
Layout l = BinomialCoefficientLayout::Builder(
HorizontalLayout::Builder(children1, children1Count),
HorizontalLayout::Builder(children2, children2Count));
HorizontalLayout::Builder({
CodePointLayout::Builder('1'),
CodePointLayout::Builder('+'),
CodePointLayout::Builder('b'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('n'),
CodePointLayout::Builder('o'),
CodePointLayout::Builder('m'),
CodePointLayout::Builder('i'),
CodePointLayout::Builder('a'),
CodePointLayout::Builder('l'),
LeftParenthesisLayout::Builder(),
CodePointLayout::Builder('3')
}),
HorizontalLayout::Builder({
CodePointLayout::Builder('1'),
RightParenthesisLayout::Builder(),
CodePointLayout::Builder(','),
CodePointLayout::Builder('1')
})
);
assert_layout_is_not_parsed(l);
}
}

10
poincare/test/parsing.cpp
View File

@@ -169,13 +169,11 @@ QUIZ_CASE(poincare_parsing_parse) {
assert_parsed_expression_is("1+2", Addition::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("(1)+2", Addition::Builder(Parenthesis::Builder(BasedInteger::Builder(1)),BasedInteger::Builder(2)));
assert_parsed_expression_is("(1+2)", Parenthesis::Builder(Addition::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2))));
Expression nAryChildren[] = {BasedInteger::Builder(1),BasedInteger::Builder(2),BasedInteger::Builder(3)};
assert_parsed_expression_is("1+2+3", Addition::Builder(nAryChildren, 3));
nAryChildren[2] = Parenthesis::Builder(Addition::Builder(BasedInteger::Builder(3),BasedInteger::Builder(4)));
assert_parsed_expression_is("1+2+(3+4)", Addition::Builder(nAryChildren, 3));
Expression::Tuple one_two_three = {BasedInteger::Builder(1),BasedInteger::Builder(2),BasedInteger::Builder(3)};
assert_parsed_expression_is("1+2+3", Addition::Builder(one_two_three));
assert_parsed_expression_is("1+2+(3+4)", Addition::Builder({BasedInteger::Builder(1), BasedInteger::Builder(2), Parenthesis::Builder(Addition::Builder(BasedInteger::Builder(3),BasedInteger::Builder(4)))}));
assert_parsed_expression_is("1×2", Multiplication::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
nAryChildren[2] = BasedInteger::Builder(3);
assert_parsed_expression_is("1×2×3", Multiplication::Builder(nAryChildren, 3));
assert_parsed_expression_is("1×2×3", Multiplication::Builder(one_two_three));
assert_parsed_expression_is("1+2×3", Addition::Builder(BasedInteger::Builder(1), Multiplication::Builder(BasedInteger::Builder(2), BasedInteger::Builder(3))));
assert_parsed_expression_is("1/2", Division::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2)));
assert_parsed_expression_is("(1/2)", Parenthesis::Builder(Division::Builder(BasedInteger::Builder(1),BasedInteger::Builder(2))));