[poincare] Parse acosh, asinh, atanh

Change-Id: I4c0f965e9bb1738c017964b8664c7867e41c5339

poincare/Makefile

@@ -28,6 +28,9 @@ objs += $(addprefix poincare/src/,\
   function.o\
   global_context.o\
   great_common_divisor.o\
+  hyperbolic_arc_cosine.o\
+  hyperbolic_arc_sine.o\
+  hyperbolic_arc_tangent.o\
   hyperbolic_cosine.o\
   hyperbolic_sine.o\
   hyperbolic_tangent.o\

poincare/include/poincare.h

@@ -24,6 +24,9 @@
 #include <poincare/function.h>
 #include <poincare/global_context.h>
 #include <poincare/great_common_divisor.h>
+#include <poincare/hyperbolic_arc_cosine.h>
+#include <poincare/hyperbolic_arc_sine.h>
+#include <poincare/hyperbolic_arc_tangent.h>
 #include <poincare/hyperbolic_cosine.h>
 #include <poincare/hyperbolic_sine.h>
 #include <poincare/hyperbolic_tangent.h>

poincare/include/poincare/expression.h

@@ -30,6 +30,9 @@ public:
     Floor,
     FracPart,
     GreatCommonDivisor,
+    HyperbolicArcCosine,
+    HyperbolicArcSine,
+    HyperbolicArcTangent,
     HyperbolicCosine,
     HyperbolicSine,
     HyperbolicTangent,

poincare/include/poincare/hyperbolic_arc_cosine.h

@@ -0,0 +1,20 @@
+#ifndef POINCARE_HYPERBOLIC_ARC_COSINE_H
+#define POINCARE_HYPERBOLIC_ARC_COSINE_H
+
+#include <poincare/function.h>
+
+namespace Poincare {
+
+class HyperbolicArcCosine : public Function {
+public:
+  HyperbolicArcCosine();
+  Type type() const override;
+  Expression * cloneWithDifferentOperands(Expression ** newOperands,
+    int numberOfOperands, bool cloneOperands = true) const override;
+private:
+  float privateApproximate(Context & context, AngleUnit angleUnit) const override;
+};
+
+}
+
+#endif

poincare/include/poincare/hyperbolic_arc_sine.h

@@ -0,0 +1,20 @@
+#ifndef POINCARE_HYPERBOLIC_ARC_SINE_H
+#define POINCARE_HYPERBOLIC_ARC_SINE_H
+
+#include <poincare/function.h>
+
+namespace Poincare {
+
+class HyperbolicArcSine : public Function {
+public:
+  HyperbolicArcSine();
+  Type type() const override;
+  Expression * cloneWithDifferentOperands(Expression ** newOperands,
+    int numberOfOperands, bool cloneOperands = true) const override;
+private:
+  float privateApproximate(Context & context, AngleUnit angleUnit) const override;
+};
+
+}
+
+#endif

poincare/include/poincare/hyperbolic_arc_tangent.h

@@ -0,0 +1,20 @@
+#ifndef POINCARE_HYPERBOLIC_ARC_TANGENT_H
+#define POINCARE_HYPERBOLIC_ARC_TANGENT_H
+
+#include <poincare/function.h>
+
+namespace Poincare {
+
+class HyperbolicArcTangent : public Function {
+public:
+  HyperbolicArcTangent();
+  Type type() const override;
+  Expression * cloneWithDifferentOperands(Expression ** newOperands,
+    int numberOfOperands, bool cloneOperands = true) const override;
+private:
+  float privateApproximate(Context & context, AngleUnit angleUnit) const override;
+};
+
+}
+
+#endif

poincare/src/expression_lexer.l

@@ -90,11 +90,14 @@ v\(n\+1\) { poincare_expression_yylval.character = Symbol::SpecialSymbols::vn1;
 w\(n\) { poincare_expression_yylval.character = Symbol::SpecialSymbols::wn; return SYMBOL; }
 w\(n\+1\) { poincare_expression_yylval.character = Symbol::SpecialSymbols::wn1; return SYMBOL; }
 acos { poincare_expression_yylval.expression = new ArcCosine(); return FUNCTION; }
+acosh { poincare_expression_yylval.expression = new HyperbolicArcCosine(); return FUNCTION; }
 abs { poincare_expression_yylval.expression = new AbsoluteValue(); return FUNCTION; }
 ans { poincare_expression_yylval.character = Symbol::SpecialSymbols::Ans; return SYMBOL; }
 arg { poincare_expression_yylval.expression = new ComplexArgument(); return FUNCTION; }
 asin { poincare_expression_yylval.expression = new ArcSine(); return FUNCTION; }
+asinh { poincare_expression_yylval.expression = new HyperbolicArcSine(); return FUNCTION; }
 atan { poincare_expression_yylval.expression = new ArcTangent(); return FUNCTION; }
+atanh { poincare_expression_yylval.expression = new HyperbolicArcTangent(); return FUNCTION; }
 binomial { poincare_expression_yylval.expression = new BinomialCoefficient(); return FUNCTION; }
 ceil { poincare_expression_yylval.expression = new Ceiling(); return FUNCTION; }
 diff { poincare_expression_yylval.expression = new Derivative(); return FUNCTION; }

poincare/src/hyperbolic_arc_cosine.cpp

@@ -0,0 +1,33 @@
+#include <poincare/hyperbolic_arc_cosine.h>
+extern "C" {
+#include <assert.h>
+#include <math.h>
+}
+
+namespace Poincare {
+
+HyperbolicArcCosine::HyperbolicArcCosine() :
+  Function("acosh")
+{
+}
+
+Expression::Type HyperbolicArcCosine::type() const {
+  return Type::HyperbolicArcCosine;
+}
+
+Expression * HyperbolicArcCosine::cloneWithDifferentOperands(Expression** newOperands,
+        int numberOfOperands, bool cloneOperands) const {
+  assert(numberOfOperands == 1);
+  assert(newOperands != nullptr);
+  HyperbolicArcCosine * c = new HyperbolicArcCosine();
+  c->setArgument(newOperands, numberOfOperands, cloneOperands);
+  return c;
+}
+
+float HyperbolicArcCosine::privateApproximate(Context& context, AngleUnit angleUnit) const {
+  assert(angleUnit != AngleUnit::Default);
+  float x = m_args[0]->approximate(context, angleUnit);
+  return logf(x+sqrtf(x*x-1.0f));
+}
+
+}

poincare/src/hyperbolic_arc_sine.cpp

@@ -0,0 +1,33 @@
+#include <poincare/hyperbolic_arc_sine.h>
+extern "C" {
+#include <assert.h>
+#include <math.h>
+}
+
+namespace Poincare {
+
+HyperbolicArcSine::HyperbolicArcSine() :
+  Function("asinh")
+{
+}
+
+Expression::Type HyperbolicArcSine::type() const {
+  return Type::HyperbolicArcSine;
+}
+
+Expression * HyperbolicArcSine::cloneWithDifferentOperands(Expression** newOperands,
+        int numberOfOperands, bool cloneOperands) const {
+  assert(numberOfOperands == 1);
+  assert(newOperands != nullptr);
+  HyperbolicArcSine * s = new HyperbolicArcSine();
+  s->setArgument(newOperands, numberOfOperands, cloneOperands);
+  return s;
+}
+
+float HyperbolicArcSine::privateApproximate(Context& context, AngleUnit angleUnit) const {
+  assert(angleUnit != AngleUnit::Default);
+  float x = m_args[0]->approximate(context, angleUnit);
+  return logf(x+sqrtf(x*x+1.0f));
+}
+
+}

poincare/src/hyperbolic_arc_tangent.cpp

@@ -0,0 +1,33 @@
+#include <poincare/hyperbolic_arc_tangent.h>
+extern "C" {
+#include <assert.h>
+#include <math.h>
+}
+
+namespace Poincare {
+
+HyperbolicArcTangent::HyperbolicArcTangent() :
+  Function("atanh")
+{
+}
+
+Expression::Type HyperbolicArcTangent::type() const {
+  return Type::HyperbolicArcTangent;
+}
+
+Expression * HyperbolicArcTangent::cloneWithDifferentOperands(Expression** newOperands,
+        int numberOfOperands, bool cloneOperands) const {
+  assert(numberOfOperands == 1);
+  assert(newOperands != nullptr);
+  HyperbolicArcTangent * t = new HyperbolicArcTangent();
+  t->setArgument(newOperands, numberOfOperands, cloneOperands);
+  return t;
+}
+
+float HyperbolicArcTangent::privateApproximate(Context& context, AngleUnit angleUnit) const {
+  assert(angleUnit != AngleUnit::Default);
+  float x = m_args[0]->approximate(context, angleUnit);
+  return 0.5f*logf((1.0f+x)/(1.0f-x));
+}
+
+}