0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_XY.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 // LPA et JCV 07/92 
16
17 #include <Standard_OutOfRange.hxx>
18 #include <Standard_ConstructionError.hxx>
19 #include <gp.hxx>
20 #include <gp_Mat2d.hxx>
21
22 inline gp_XY::gp_XY () : x(0.), y(0.) { } 
23
24 inline gp_XY::gp_XY (const Standard_Real X,
25                      const Standard_Real Y) :  x (X),  y (Y) { }
26
27 inline void gp_XY::SetCoord (const Standard_Integer i,
28                              const Standard_Real X)
29 {
30   Standard_OutOfRange_Raise_if( i < 1 || i > 2,NULL);
31   (&x)[i-1] = X;
32 }
33
34 inline void gp_XY::SetCoord (const Standard_Real X,
35                              const Standard_Real Y)
36 { x = X;  y = Y; }
37
38 inline void gp_XY::SetX (const Standard_Real X)
39 { x = X; }
40
41 inline void gp_XY::SetY (const Standard_Real Y)
42 { y = Y; }
43
44 inline Standard_Real gp_XY::Coord (const Standard_Integer i) const
45 {
46   Standard_OutOfRange_Raise_if( i < 1 || i > 2,NULL);
47   return (&x)[i-1];
48 }
49
50 inline Standard_Real& gp_XY::ChangeCoord (const Standard_Integer theIndex)
51 {
52   Standard_OutOfRange_Raise_if(theIndex < 1 || theIndex > 2,NULL);
53   return (&x)[theIndex - 1];
54 }
55
56 inline void gp_XY::Coord (Standard_Real& X,
57                           Standard_Real& Y) const
58 { X = x;  Y = y; }
59
60 inline Standard_Real gp_XY::X () const
61 { return x; }
62
63 inline Standard_Real gp_XY::Y () const
64 { return y; }
65
66 inline Standard_Real gp_XY::Modulus () const
67
68   return sqrt (x * x + y * y);
69 }
70
71 inline Standard_Real gp_XY::SquareModulus () const
72 {
73   return x * x + y * y;
74 }
75
76 inline void gp_XY::Add (const gp_XY& Other) {
77   x += Other.x;
78   y += Other.y;
79 }
80
81 inline gp_XY gp_XY::Added (const gp_XY& Other) const {
82   return gp_XY(x + Other.X(),y + Other.Y());
83 }
84
85 inline Standard_Real gp_XY::Crossed (const gp_XY& Right) const {
86   return x * Right.y - y * Right.x;
87 }
88
89 inline Standard_Real gp_XY::CrossMagnitude (const gp_XY& Right) const
90 {
91   Standard_Real val = x * Right.y - y * Right.x;
92   if (val < 0) val = - val;
93   return val;
94 }
95
96 inline Standard_Real gp_XY::CrossSquareMagnitude (const gp_XY& Right) const {
97   Standard_Real Zresult =  x * Right.y - y * Right.x;
98   return Zresult * Zresult;
99 }
100
101 inline void gp_XY::Divide (const Standard_Real Scalar)
102 {
103   x /= Scalar;
104   y /= Scalar;
105 }
106
107 inline gp_XY gp_XY::Divided (const Standard_Real Scalar) const {
108   return gp_XY(x / Scalar,y / Scalar);
109 }
110
111 inline Standard_Real gp_XY::Dot (const gp_XY& Other) const
112 {
113   return x * Other.x + y * Other.y;
114 }
115
116 inline void gp_XY::Multiply (const Standard_Real Scalar)
117 {
118   x *= Scalar;
119   y *= Scalar;
120 }
121
122 inline void gp_XY::Multiply (const gp_XY& Other)
123 {
124   x *= Other.x;
125   y *= Other.y;
126 }
127
128 inline void gp_XY::Multiply (const gp_Mat2d& Matrix)
129 {
130   const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
131   Standard_Real Xresult = Mat2d00 * x + Mat2d01 * y;
132   y                     = Mat2d10 * x + Mat2d11 * y;
133   x                     = Xresult;
134 }
135
136 inline gp_XY gp_XY::Multiplied (const Standard_Real Scalar) const {
137   return gp_XY(x * Scalar,y * Scalar);
138 }
139
140 inline gp_XY gp_XY::Multiplied (const gp_XY& Other) const {
141   return(gp_XY(x * Other.X(),y * Other.Y()));
142 }
143
144 inline gp_XY gp_XY::Multiplied (const gp_Mat2d& Matrix) const
145 {
146   const Standard_Address M = (Standard_Address)&(Matrix.matrix[0][0]);
147   return gp_XY (Mat2d00 * x + Mat2d01 * y,
148                 Mat2d10 * x + Mat2d11 * y);
149 }
150
151 inline void gp_XY::Normalize ()
152 {
153   Standard_Real D = Modulus();
154   Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
155                                        "gp_XY::Normalize() - vector has zero norm");
156   x = x / D;   y = y / D;
157 }
158
159 inline gp_XY gp_XY::Normalized () const
160 {
161   Standard_Real D = Modulus();
162   Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
163                                        "gp_XY::Normalized() - vector has zero norm");
164   return gp_XY (x / D, y / D);
165 }
166
167 inline void gp_XY::Reverse ()
168 {  x = - x;    y = - y;  }
169
170 inline gp_XY gp_XY::Reversed () const
171 {
172   gp_XY Coord2D = *this;
173   Coord2D.Reverse();
174   return Coord2D;
175 }
176
177 inline void gp_XY::SetLinearForm (const Standard_Real L,
178                                   const gp_XY& Left,
179                                   const Standard_Real R,
180                                   const gp_XY& Right) {
181   x = L * Left.x + R * Right.x;
182   y = L * Left.y + R * Right.y;
183 }
184
185 inline void gp_XY::SetLinearForm (const Standard_Real L,
186                                   const gp_XY& Left,
187                                   const gp_XY& Right) {
188   x = L * Left.x + Right.x;
189   y = L * Left.y + Right.y;
190 }
191
192 inline void gp_XY::SetLinearForm (const gp_XY& Left,
193                                   const gp_XY& Right) {
194   x = Left.x + Right.x;
195   y = Left.y + Right.y;
196 }
197
198 inline void gp_XY::SetLinearForm (const Standard_Real A1,
199                                   const gp_XY& XY1,
200                                   const Standard_Real A2,
201                                   const gp_XY& XY2,
202                                   const gp_XY& XY3) {
203   x = A1 * XY1.x + A2 * XY2.x + XY3.x;
204   y = A1 * XY1.y + A2 * XY2.y + XY3.y;
205 }
206
207 inline void gp_XY::Subtract (const gp_XY& Right)
208 {
209   x -= Right.x;
210   y -= Right.y;
211 }
212
213 inline gp_XY gp_XY::Subtracted (const gp_XY& Right) const
214 {
215   gp_XY Coord2D = *this;
216   Coord2D.Subtract(Right);
217   return Coord2D;
218 }
219
220 inline gp_XY operator* (const gp_Mat2d& Matrix,
221                         const gp_XY& Coord1) {
222   return Coord1.Multiplied(Matrix);
223 }
224
225 inline gp_XY operator* (const Standard_Real Scalar,
226                         const gp_XY& Coord1) {
227   return Coord1.Multiplied(Scalar);
228 }
229