0022904: Clean up sccsid variables
[occt.git] / src / Expr / Expr_Exponentiate.cxx
1 // Copyright:   Matra-Datavision 1991
2 // File:        Expr_Exponentiate.cxx
3 // Created:     Thu May 30 16:44:30 1991
4 // Author:      Arnaud BOUZY
5 //              <adn>
6
7 #include <Expr_Exponentiate.ixx>
8 #include <Expr_NumericValue.hxx>
9 #include <Expr_SequenceOfGeneralExpression.hxx>
10 #include <Expr_Difference.hxx>
11 #include <Expr_Product.hxx>
12 #include <Expr_LogOfe.hxx>
13 #include <Expr_Sum.hxx>
14 #include <Expr_Operators.hxx>
15 #include <Expr.hxx>
16
17 Expr_Exponentiate::Expr_Exponentiate (const Handle(Expr_GeneralExpression)& exp1, const Handle(Expr_GeneralExpression)& exp2)
18 {
19   CreateFirstOperand(exp1);
20   CreateSecondOperand(exp2);
21 }
22
23
24 Handle(Expr_GeneralExpression) Expr_Exponentiate::ShallowSimplified() const
25 {
26   Handle(Expr_GeneralExpression) myfirst = FirstOperand();
27   Handle(Expr_GeneralExpression) mysecond = SecondOperand();
28
29   if (mysecond->IsKind(STANDARD_TYPE(Expr_NumericValue))) {
30     Handle(Expr_NumericValue) myNVs = Handle(Expr_NumericValue)::DownCast(mysecond);
31     Standard_Real myvals = myNVs->GetValue();
32     if (myvals == 0.0) {
33       // case X ** 0
34       return new Expr_NumericValue(1.0);
35     }
36     if (myvals == 1.0) {
37       // case X ** 1
38       return myfirst;
39     }
40     if (myfirst->IsKind(STANDARD_TYPE(Expr_NumericValue))) {
41       Handle(Expr_NumericValue) myNVf = Handle(Expr_NumericValue)::DownCast(myfirst);
42       return new Expr_NumericValue(Pow(myNVf->GetValue(),myvals));
43     }
44   }
45   if (myfirst->IsKind(STANDARD_TYPE(Expr_NumericValue))) {
46     Handle(Expr_NumericValue) myNVf = Handle(Expr_NumericValue)::DownCast(myfirst);
47     Standard_Real myValf = myNVf->GetValue();
48     if (myValf == 1.0) {
49       return myNVf;
50     }
51   }
52   Handle(Expr_Exponentiate) me = this;
53   return me;
54 }
55
56 Handle(Expr_GeneralExpression) Expr_Exponentiate::Copy () const
57 {
58   return new Expr_Exponentiate(Expr::CopyShare(FirstOperand()),
59                                Expr::CopyShare(SecondOperand()));
60 }
61
62 Standard_Boolean Expr_Exponentiate::IsIdentical (const Handle(Expr_GeneralExpression)& Other) const
63 {
64   Standard_Boolean ident = Standard_False;
65   if (Other->IsKind(STANDARD_TYPE(Expr_Exponentiate))) {
66     Handle(Expr_GeneralExpression) myfirst = FirstOperand();
67     Handle(Expr_GeneralExpression) mysecond = SecondOperand();
68     if (myfirst->IsIdentical(Other->SubExpression(1))) {
69       if (mysecond->IsIdentical(Other->SubExpression(2))) {
70         ident = Standard_True;
71       }
72     }
73   }
74   return ident;
75 }
76
77 Standard_Boolean Expr_Exponentiate::IsLinear () const
78 {
79   return !ContainsUnknowns();
80 }
81
82 Handle(Expr_GeneralExpression) Expr_Exponentiate::Derivative (const Handle(Expr_NamedUnknown)& X) const
83 {
84
85   if (!Contains(X)) {
86     return new Expr_NumericValue(0.0);
87   }
88
89   // Derivate of h(X) ** g(X) is :
90   // h(X) * (g(X) ** (h(X)-1)) * g'(X) +
91   // (g(X) ** h(X)) * Log(g(X)) * h'(X)
92   Handle(Expr_GeneralExpression) myfirst = FirstOperand();
93   Handle(Expr_GeneralExpression) mysecond = SecondOperand();
94
95   Handle(Expr_GeneralExpression) myfder = myfirst->Derivative(X);
96   Handle(Expr_GeneralExpression) mysder = mysecond->Derivative(X);
97
98   Expr_SequenceOfGeneralExpression prod1;
99   prod1.Append(Expr::CopyShare(mysecond));    // h(X)
100   
101   Handle(Expr_Difference) difh1 = Expr::CopyShare(mysecond) - 1.0; // h(X)-1
102   Handle(Expr_Exponentiate) exp1 = new Expr_Exponentiate(Expr::CopyShare(myfirst),difh1->ShallowSimplified());
103   prod1.Append(exp1->ShallowSimplified());       // g(X) ** (h(X)-1)
104
105   prod1.Append(myfder);     // g'(X)
106   
107   Handle(Expr_Product) firstmember = new Expr_Product(prod1);
108   
109   Expr_SequenceOfGeneralExpression prod2;
110   Handle(Expr_Exponentiate) exp2 = new Expr_Exponentiate(Expr::CopyShare(myfirst),Expr::CopyShare(mysecond));
111   prod2.Append(exp2->ShallowSimplified());   // g(X) ** h(X)
112   
113   Handle(Expr_LogOfe) log = new Expr_LogOfe(Expr::CopyShare(myfirst));
114   prod2.Append(log->ShallowSimplified());    // Log(g(X))
115   prod2.Append(mysder);                      // h'(X)
116   
117   Handle(Expr_Product) secondmember = new Expr_Product(prod2);
118
119   Handle(Expr_Sum) resu = firstmember->ShallowSimplified() + secondmember->ShallowSimplified();
120   return resu->ShallowSimplified();
121 }
122
123
124 Standard_Real Expr_Exponentiate::Evaluate(const Expr_Array1OfNamedUnknown& vars, const TColStd_Array1OfReal& vals) const
125 {
126   Standard_Real res = FirstOperand()->Evaluate(vars,vals);
127   return ::Pow(res,SecondOperand()->Evaluate(vars,vals));
128 }
129
130 TCollection_AsciiString Expr_Exponentiate::String() const
131 {
132   Handle(Expr_GeneralExpression) op1 = FirstOperand();
133   Handle(Expr_GeneralExpression) op2 = SecondOperand();
134   TCollection_AsciiString str;
135   if (op1->NbSubExpressions() > 1) {
136     str = "(";
137     str += op1->String();
138     str += ")";
139   }
140   else {
141     str = op1->String();
142   }
143   str += "^";
144   if (op2->NbSubExpressions() > 1) {
145     str += "(";
146     str += op2->String();
147     str += ")";
148   }
149   else {
150     str += op2->String();
151   }
152   return str;
153 }