TrioCFD 1.9.8
TrioCFD documentation
Loading...
Searching...
No Matches
Polynome.h
1/****************************************************************************
2* Copyright (c) 2022, CEA
3* All rights reserved.
4*
5* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
6* 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
7* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
8* 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
9*
10* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
11* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
12* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
13*
14*****************************************************************************/
15
16#ifndef Polynome_included
17#define Polynome_included
18
19#include <TRUSTTab.h>
20
21
22/*! @brief Polynome a n variables, n <= 4 Implementation des coefficients a l'aide d'un DoubleTab
23 *
24 */
25class Polynome : public Objet_U
26{
27 Declare_instanciable(Polynome);
28
29public :
30 inline Polynome(int n1);
31 inline Polynome(int n1, int n2);
32 inline Polynome(int n1, int n2, int n3);
33 inline Polynome(int n1, int n2, int n3, int n4);
34 inline Polynome(const DoubleTab& );
35 inline int degre(int ) const;
36 inline double& coeff(int n1);
37 inline double& coeff(int n1, int n2);
38 inline double& coeff(int n1, int n2, int n3);
39 inline double& coeff(int n1, int n2, int n3, int n4);
40 inline double coeff(int n1) const;
41 inline double coeff(int n1, int n2) const;
42 inline double coeff(int n1, int n2, int n3) const;
43 inline double coeff(int n1, int n2, int n3, int n4) const;
44 double operator()(double x1) const;
45 double operator()(double x1, double x2) const;
46 double operator()(double x1, double x2, double x3) const;
47 double operator()(double x1, double x2, double x3, double x4) const;
48
49 void derive(int =0);
50 void integre(int =0);
51
52 double derive(double x1) const;
53 double derive(double x1, double x2) const;
54 double derive(double x1, double x2, double x3) const;
55 double derive(double x1, double x2, double x3, double x4) const;
56
57 double integre(double x1) const;
58 double integre(double x1, double x2) const;
59 double integre(double x1, double x2, double x3) const;
60 double integre(double x1, double x2, double x3, double x4) const;
61
62 Polynome& operator +=(const Polynome&);
63 Polynome& operator -=(const Polynome&);
64 Polynome& operator *=(const Polynome&);
65 Polynome& operator *=(double);
66 Polynome& operator /=(double);
67
68private :
69 DoubleTab coeff_;
70};
71
72
73
74/*! @brief Construction d'un polynome a une variable de degre n1
75 *
76 * @param (int n1) degre du polynome
77 */
78inline Polynome::Polynome(int n1) : coeff_(++n1) {}
79
80/*! @brief Construction d'un polynome a 2 variables de degres n1 et n2
81 *
82 * @param (int n1) degre de la premiere variable
83 * @param (int n2) degre de la deuxieme variable
84 */
85inline Polynome::Polynome(int n1, int n2) : coeff_(++n1, ++n2) {}
86
87/*! @brief Construction d'un polynome a 3 variables de degres n1, n2 et n3
88 *
89 * @param (int n1) degre de la premiere variable
90 * @param (int n2) degre de la deuxieme variable
91 * @param (int n3) degre de la troisieme variable
92 */
93inline Polynome::Polynome(int n1, int n2, int n3) : coeff_(++n1, ++n2, ++n3) {}
94
95/*! @brief Construction d'un polynome a 4 variables de degres n1, n2, n3 et n4
96 *
97 * @param (int n1) degre de la premiere variable
98 * @param (int n2) degre de la deuxieme variable
99 * @param (int n3) degre de la troisieme variable
100 * @param (int n4) degre de la quatrieme variable
101 */
102inline Polynome::Polynome(int n1, int n2, int n3, int n4) : coeff_(++n1, ++n2, ++n3, ++n4) {}
103
104/*! @brief Construction d'un polynome a partir du tableau de ses coefficients
105 *
106 * @param (const DoubleTab& t) le tableau des coefficients du polynome (1 a 4 dimensions)
107 */
108inline Polynome::Polynome(const DoubleTab& t) : coeff_(t) {}
109
110/*! @brief Retourne le degre du polynome par rapport a la ieme variable
111 *
112 * @param (int i) l'indice de la variable consideree
113 * @return (int) degre du polynome
114 */
115inline int Polynome::degre(int i) const
116{
117 return coeff_.dimension(i)-1;
118}
119
120/*! @brief Retourne le coefficient du terme de degre n1
121 *
122 * @param (int n1) degre
123 * @return (double&) coefficient
124 */
125inline double& Polynome::coeff(int n1)
126{
127 return coeff_(n1);
128}
129
130/*! @brief Retourne le coefficient du terme de degre n1,n2
131 *
132 * @param (int n1) degre
133 * @param (int n2) degre
134 * @return (double&) coefficient
135 */
136inline double& Polynome::coeff(int n1, int n2)
137{
138 return coeff_(n1, n2);
139}
140
141/*! @brief Retourne le coefficient du terme de degre n1,n2,n3
142 *
143 * @param (int n1) degre
144 * @param (int n2) degre
145 * @param (int n3) degre
146 * @return (double&) coefficient
147 */
148inline double& Polynome::coeff(int n1, int n2, int n3)
149{
150 return coeff_(n1, n2, n3);
151}
152
153/*! @brief Retourne le coefficient du terme de degre n1,n2,n3,n4
154 *
155 * @param (int n1) degre
156 * @param (int n2) degre
157 * @param (int n3) degre
158 * @param (int n4) degre
159 * @return (double&) coefficient
160 */
161inline double& Polynome::coeff(int n1, int n2, int n3, int n4)
162{
163 return coeff_(n1, n2, n3, n4);
164}
165
166/*! @brief Retourne le coefficient du terme de degre n1
167 *
168 * @param (int n1) degre
169 * @return (double) coefficient
170 */
171inline double Polynome::coeff(int n1) const
172{
173 return coeff_(n1);
174}
175
176/*! @brief Retourne le coefficient du terme de degre n1,n2
177 *
178 * @param (int n1) degre
179 * @param (int n2) degre
180 * @return (double) coefficient
181 */
182inline double Polynome::coeff(int n1, int n2) const
183{
184 return coeff_(n1, n2);
185}
186
187/*! @brief Retourne le coefficient du terme de degre n1,n2,n3
188 *
189 * @param (int n1) degre
190 * @param (int n2) degre
191 * @param (int n3) degre
192 * @return (double) coefficient
193 */
194inline double Polynome::coeff(int n1, int n2, int n3) const
195{
196 return coeff_(n1, n2, n3);
197}
198
199/*! @brief Retourne le coefficient du terme de degre n1,n2,n3,n4
200 *
201 * @param (int n1) degre
202 * @param (int n2) degre
203 * @param (int n3) degre
204 * @param (int n4) degre
205 * @return (double) coefficient
206 */
207inline double Polynome::coeff(int n1, int n2, int n3, int n4) const
208{
209 return coeff_(n1, n2, n3, n4);
210}
211#endif //Polynome_H
212
Objet_U::Objet_U
Objet_U()
Constructeur par defaut : attribue un numero d'identifiant unique a l'objet (object_id_),...
Definition Objet_U.cpp:55
Polynome::derive
void derive(int=0)
Non code.
Definition Polynome.cpp:200
Polynome::Polynome
Polynome(int n1)
Construction d'un polynome a une variable de degre n1.
Definition Polynome.h:78
Polynome::coeff
double & coeff(int n1)
Retourne le coefficient du terme de degre n1.
Definition Polynome.h:125
Polynome::operator/=
Polynome & operator/=(double)
Non code.
Definition Polynome.cpp:341
Polynome::operator+=
Polynome & operator+=(const Polynome &)
Non code.
Definition Polynome.cpp:301
Polynome::operator*=
Polynome & operator*=(const Polynome &)
Non code.
Definition Polynome.cpp:321
Polynome::operator()
double operator()(double x1) const
Calcul de la valeur du polynome au point x1.
Definition Polynome.cpp:51
Polynome::integre
void integre(int=0)
Non code.
Definition Polynome.cpp:209
Polynome::degre
int degre(int) const
Retourne le degre du polynome par rapport a la ieme variable.
Definition Polynome.h:115
Polynome::operator-=
Polynome & operator-=(const Polynome &)
Non code.
Definition Polynome.cpp:311