0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_Mat2d.lxx
1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <gp.hxx>
16 #include <Standard_OutOfRange.hxx>
17
18 #define Mat2d00 ((Standard_Real*)M)[0]
19 #define Mat2d01 ((Standard_Real*)M)[1]
20 #define Mat2d10 ((Standard_Real*)M)[2]
21 #define Mat2d11 ((Standard_Real*)M)[3]
22
23 #define Nat2d00 ((Standard_Real*)N)[0]
24 #define Nat2d01 ((Standard_Real*)N)[1]
25 #define Nat2d10 ((Standard_Real*)N)[2]
26 #define Nat2d11 ((Standard_Real*)N)[3]
27
28 #define Oat2d00 ((Standard_Real*)O)[0]
29 #define Oat2d01 ((Standard_Real*)O)[1]
30 #define Oat2d10 ((Standard_Real*)O)[2]
31 #define Oat2d11 ((Standard_Real*)O)[3]
32
33 inline gp_Mat2d::gp_Mat2d ()
34 {
35   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
36   Mat2d00 = Mat2d01 = Mat2d10 = Mat2d11 = 0.0;
37 }
38
39 inline void gp_Mat2d::SetDiagonal (const Standard_Real X1,
40                             const Standard_Real X2)
41 {
42   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
43   Mat2d00 = X1; Mat2d11 = X2;
44 }
45
46 inline void gp_Mat2d::SetIdentity ()
47 {
48   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
49   Mat2d00 = Mat2d11 = 1.0;
50   Mat2d01 = Mat2d10 = 0.0;
51 }
52
53 inline void gp_Mat2d::SetRotation (const Standard_Real Ang)
54 {
55   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
56   Standard_Real SinA = sin(Ang);
57   Standard_Real CosA = cos(Ang);
58   Mat2d00 = Mat2d11 = CosA;
59   Mat2d01 = -SinA;
60   Mat2d10 =  SinA;
61 }
62
63 inline void gp_Mat2d::SetScale (const Standard_Real S)
64 {
65   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
66   Mat2d00 = Mat2d11 = S;
67   Mat2d01 = Mat2d10 = 0.0;
68 }
69
70 inline void gp_Mat2d::SetValue (const Standard_Integer Row, 
71                                 const Standard_Integer Col, 
72                                 const Standard_Real Value)
73 {
74   Standard_OutOfRange_Raise_if
75     (Row < 1 || Row > 2 || Col < 1 || Col > 2, " ");
76   matrix[Row-1][Col-1] = Value;
77 }
78
79 inline Standard_Real gp_Mat2d::Determinant () const
80 {
81   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
82   return  Mat2d00 * Mat2d11 - Mat2d10 * Mat2d01;
83 }
84
85 inline const Standard_Real& gp_Mat2d::Value (const Standard_Integer Row, 
86                                              const Standard_Integer Col) const
87 {
88   Standard_OutOfRange_Raise_if
89     (Row < 1 || Row > 2 || Col < 1 || Col > 2, " ");
90   return matrix[Row-1][Col-1];
91 }
92
93 inline  Standard_Real& 
94 gp_Mat2d::ChangeValue (const Standard_Integer Row, 
95                        const Standard_Integer Col)
96 {
97   Standard_OutOfRange_Raise_if
98     (Row < 1 || Row > 2 || Col < 1 || Col > 2, " ");
99   return matrix[Row-1][Col-1];
100 }
101
102 inline Standard_Boolean gp_Mat2d::IsSingular () const
103 {
104   Standard_Real det = Determinant();
105   if (det < 0) det = - det;
106   return det <= gp::Resolution();
107 }
108
109 inline void gp_Mat2d::Add (const gp_Mat2d& Other)
110 {
111   const Standard_Address M = (Standard_Address)&(      matrix[0][0]);
112   const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
113   Mat2d00 += Oat2d00;
114   Mat2d01 += Oat2d01;
115   Mat2d10 += Oat2d10;
116   Mat2d11 += Oat2d11;
117 }
118
119 inline gp_Mat2d gp_Mat2d::Added (const gp_Mat2d& Other) const
120 {
121   gp_Mat2d NewMat2d;
122   const Standard_Address M = (Standard_Address)&(         matrix[0][0]);
123   const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
124   const Standard_Address O = (Standard_Address)&(Other   .matrix[0][0]);
125   Nat2d00 = Mat2d00 + Oat2d00;
126   Nat2d01 = Mat2d01 + Oat2d01;
127   Nat2d10 = Mat2d10 + Oat2d10;
128   Nat2d11 = Mat2d11 + Oat2d11;
129   return NewMat2d;
130 }
131
132 inline void gp_Mat2d::Divide (const Standard_Real Scalar)
133 {
134   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
135   Mat2d00 /= Scalar;
136   Mat2d01 /= Scalar;
137   Mat2d10 /= Scalar;
138   Mat2d11 /= Scalar;
139 }
140
141 inline gp_Mat2d gp_Mat2d::Divided (const Standard_Real Scalar) const
142 {
143   gp_Mat2d NewMat2d;
144   const Standard_Address M = (Standard_Address)&(         matrix[0][0]);
145   const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
146   Nat2d00 = Mat2d00 / Scalar;
147   Nat2d01 = Mat2d01 / Scalar;
148   Nat2d10 = Mat2d10 / Scalar;
149   Nat2d11 = Mat2d11 / Scalar;
150   return NewMat2d;
151 }
152
153 inline gp_Mat2d gp_Mat2d::Inverted () const
154 {
155   gp_Mat2d NewMat = *this;
156   NewMat.Invert();
157   return NewMat;
158 }
159
160 inline gp_Mat2d gp_Mat2d::Multiplied (const gp_Mat2d& Other) const
161 {
162   gp_Mat2d NewMat2d = *this;
163   NewMat2d.Multiply(Other);
164   return NewMat2d;
165 }
166
167 inline void gp_Mat2d::Multiply (const gp_Mat2d& Other)
168 {
169   Standard_Real T00,T10;
170   const Standard_Address M = (Standard_Address)&(      matrix[0][0]);
171   const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
172   T00     = Mat2d00 * Oat2d00 + Mat2d01 * Oat2d10;
173   T10     = Mat2d10 * Oat2d00 + Mat2d11 * Oat2d10;
174   Mat2d01 = Mat2d00 * Oat2d01 + Mat2d01 * Oat2d11;
175   Mat2d11 = Mat2d10 * Oat2d01 + Mat2d11 * Oat2d11;
176   Mat2d00 = T00;
177   Mat2d10 = T10;
178 }
179
180 inline void gp_Mat2d::PreMultiply (const gp_Mat2d& Other)
181 {
182   Standard_Real T00,T01;
183   const Standard_Address M = (Standard_Address)&(      matrix[0][0]);
184   const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
185   T00     = Oat2d00 * Mat2d00 + Oat2d01 * Mat2d10;
186   Mat2d10 = Oat2d10 * Mat2d00 + Oat2d11 * Mat2d10;
187   T01     = Oat2d00 * Mat2d01 + Oat2d01 * Mat2d11;
188   Mat2d11 = Oat2d10 * Mat2d01 + Oat2d11 * Mat2d11;
189   Mat2d00 = T00;
190   Mat2d01 = T01;
191 }
192
193 inline gp_Mat2d gp_Mat2d::Multiplied (const Standard_Real Scalar) const
194 {
195   gp_Mat2d NewMat2d;
196   const Standard_Address M = (Standard_Address)&(         matrix[0][0]);
197   const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
198   Nat2d00 = Mat2d00 * Scalar;
199   Nat2d01 = Mat2d01 * Scalar;
200   Nat2d10 = Mat2d10 * Scalar;
201   Nat2d11 = Mat2d11 * Scalar;
202   return NewMat2d;
203 }
204
205 inline void gp_Mat2d::Multiply (const Standard_Real Scalar)
206 {
207   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
208   Mat2d00 *= Scalar;
209   Mat2d01 *= Scalar;
210   Mat2d10 *= Scalar;
211   Mat2d11 *= Scalar;
212 }
213
214 inline gp_Mat2d gp_Mat2d::Powered (const Standard_Integer N) const
215 {
216   gp_Mat2d Mat2dN = *this;
217   Mat2dN.Power (N);
218   return Mat2dN;
219 }
220
221 inline void gp_Mat2d::Subtract (const gp_Mat2d& Other)
222 {
223   const Standard_Address M = (Standard_Address)&(      matrix[0][0]);
224   const Standard_Address O = (Standard_Address)&(Other.matrix[0][0]);
225   Mat2d00 -= Oat2d00;
226   Mat2d01 -= Oat2d01;
227   Mat2d10 -= Oat2d10;
228   Mat2d11 -= Oat2d11;
229 }
230
231 inline gp_Mat2d gp_Mat2d::Subtracted (const gp_Mat2d& Other) const
232 {
233   gp_Mat2d NewMat2d;
234   const Standard_Address M = (Standard_Address)&(         matrix[0][0]);
235   const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
236   const Standard_Address O = (Standard_Address)&(Other   .matrix[0][0]);
237   Nat2d00 = Mat2d00 - Oat2d00;
238   Nat2d01 = Mat2d01 - Oat2d01;
239   Nat2d10 = Mat2d10 - Oat2d10;
240   Nat2d11 = Mat2d11 - Oat2d11;
241   return NewMat2d;
242 }
243
244 inline void gp_Mat2d::Transpose ()
245 {
246   const Standard_Address M = (Standard_Address)&(matrix[0][0]);
247   Standard_Real Temp;
248   Temp     = Mat2d01;
249   Mat2d01  = Mat2d10;
250   Mat2d10  = Temp;
251 }
252
253 inline gp_Mat2d gp_Mat2d::Transposed () const
254 {
255   gp_Mat2d NewMat2d;
256   const Standard_Address M = (Standard_Address)&(         matrix[0][0]);
257   const Standard_Address N = (Standard_Address)&(NewMat2d.matrix[0][0]);
258   Nat2d10 = Mat2d01;
259   Nat2d01 = Mat2d10;
260   Nat2d00 = Mat2d00;
261   Nat2d11 = Mat2d11;
262   return NewMat2d; 
263 }
264
265 inline gp_Mat2d operator* (const Standard_Real Scalar,
266                            const gp_Mat2d& Mat2D)
267 { return Mat2D.Multiplied (Scalar); }
268