0032137: Coding Rules - merge redundant .lxx files into header files within Package gp
[occt.git] / src / gp / gp_Vec.lxx
diff --git a/src/gp/gp_Vec.lxx b/src/gp/gp_Vec.lxx
deleted file mode 100644 (file)
index 40283e9..0000000
+++ /dev/null
@@ -1,324 +0,0 @@
-// Copyright (c) 1995-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-// Modif JCV 07/12/90 introduction classe XYZ dans le package gp
-// LPA et JCV 07/92 mise a jour
-
-#include <gp.hxx>
-#include <gp_Dir.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Trsf.hxx>
-#include <gp_VectorWithNullMagnitude.hxx>
-#include <Standard_ConstructionError.hxx>
-
-inline gp_Vec::gp_Vec() { }
-
-inline gp_Vec::gp_Vec (const gp_Dir& V) { coord = V.XYZ(); }
-
-inline gp_Vec::gp_Vec (const gp_XYZ& Coord) : coord(Coord) { }
-
-inline gp_Vec::gp_Vec (const Standard_Real Xv,
-                      const Standard_Real Yv,
-                      const Standard_Real Zv)
-               : coord (Xv, Yv, Zv)   { }
-
-inline gp_Vec::gp_Vec (const gp_Pnt& P1,
-                      const gp_Pnt& P2)
-{ coord = P2.XYZ().Subtracted(P1.XYZ()); }
-
-inline void gp_Vec::SetCoord (const Standard_Integer Index,
-                             const Standard_Real Xi)
-{ coord.SetCoord (Index, Xi); }
-
-inline void gp_Vec::SetCoord (const Standard_Real Xv,
-                             const Standard_Real Yv,
-                             const Standard_Real Zv)
-{
-  coord.SetX(Xv);
-  coord.SetY(Yv);
-  coord.SetZ(Zv);
-}
-
-inline void gp_Vec::SetX (const Standard_Real X)
-{ coord.SetX (X); }
-
-inline void gp_Vec::SetY (const Standard_Real Y)
-{ coord.SetY (Y); }
-
-inline void gp_Vec::SetZ (const Standard_Real Z)
-{ coord.SetZ (Z); }
-
-inline void gp_Vec::SetXYZ (const gp_XYZ& Coord)
-{ coord = Coord; }
-
-inline Standard_Real gp_Vec::Coord (const Standard_Integer Index) const
-{ return coord.Coord (Index); }
-
-inline void gp_Vec::Coord(Standard_Real& Xv, 
-                         Standard_Real& Yv,
-                         Standard_Real& Zv) const
-{
-  Xv = coord.X();
-  Yv = coord.Y();
-  Zv = coord.Z();
-}
-
-inline Standard_Real gp_Vec::X() const
-{ return coord.X(); }
-     
-inline Standard_Real gp_Vec::Y() const
-{ return coord.Y(); }
-
-inline Standard_Real gp_Vec::Z() const
-{ return coord.Z(); }
-     
-inline const gp_XYZ& gp_Vec::XYZ () const
-{ return coord; }
-
-inline Standard_Boolean gp_Vec::IsNormal
-(const gp_Vec& Other,
- const Standard_Real AngularTolerance) const
-{
-  Standard_Real Ang = M_PI / 2.0 - Angle(Other);
-  if (Ang < 0) Ang = - Ang;
-  return  Ang <= AngularTolerance;
-}    
-
-inline Standard_Boolean gp_Vec::IsOpposite
-(const gp_Vec& Other,
- const Standard_Real AngularTolerance) const
-{
-  Standard_Real Ang = M_PI - Angle(Other);
-  return Ang <= AngularTolerance;
-}    
-
-inline Standard_Boolean gp_Vec::IsParallel
-(const gp_Vec& Other,
- const Standard_Real AngularTolerance) const
-{
-  Standard_Real Ang = Angle (Other);
-  return   Ang <= AngularTolerance || M_PI - Ang <= AngularTolerance;
-}    
-
-inline Standard_Real gp_Vec::Angle (const gp_Vec& Other) const
-{
-  //    Commentaires :
-  //    Au dessus de 45 degres l'arccos donne la meilleur precision pour le
-  //    calcul de l'angle. Sinon il vaut mieux utiliser l'arcsin.
-  //    Les erreurs commises sont loin d'etre negligeables lorsque l'on est
-  //    proche de zero ou de 90 degres.
-  //    En 3d les valeurs angulaires sont toujours positives et comprises entre
-  //    0 et Pi.
-  
-  gp_VectorWithNullMagnitude_Raise_if
-    (coord.Modulus()       <= gp::Resolution() ||
-     Other.coord.Modulus() <= gp::Resolution(), " ");
-  return (gp_Dir(coord)).Angle(Other);
-}
-
-inline Standard_Real gp_Vec::AngleWithRef (const gp_Vec& Other,
-                                          const gp_Vec& Vref) const
-{
-  gp_VectorWithNullMagnitude_Raise_if
-    (coord.Modulus()       <= gp::Resolution() ||
-     Vref.coord.Modulus () <= gp::Resolution() ||
-     Other.coord.Modulus() <= gp::Resolution(), " ");
-  return (gp_Dir(coord)).AngleWithRef(Other,Vref);
-} 
-
-inline Standard_Real gp_Vec::Magnitude() const
-{ return coord.Modulus(); }
-
-inline Standard_Real gp_Vec::SquareMagnitude() const
-{ return coord.SquareModulus(); }
-
-inline void gp_Vec::Add (const gp_Vec& Other)
-{ coord.Add (Other.coord); }
-
-inline gp_Vec gp_Vec::Added (const gp_Vec& Other) const
-{
-  gp_Vec V = *this;
-  V.coord.Add (Other.coord);
-  return V;
-}
-
-inline void gp_Vec::Subtract (const gp_Vec& Right)
-{ coord.Subtract (Right.coord); }
-
-inline gp_Vec gp_Vec::Subtracted (const gp_Vec& Right) const
-{
-  gp_Vec V = *this;
-   V.coord.Subtract(Right.coord);
-   return V;
-}
-
-inline void gp_Vec::Multiply (const Standard_Real Scalar)
-{ coord.Multiply(Scalar); }
-
-inline gp_Vec gp_Vec::Multiplied (const Standard_Real Scalar) const
-{
-  gp_Vec V = *this;
-  V.coord.Multiply (Scalar);
-  return V;
-}
-
-inline void gp_Vec::Divide (const Standard_Real Scalar)
-{ coord.Divide (Scalar); }
-
-inline gp_Vec gp_Vec::Divided (const Standard_Real Scalar) const
-{
-  gp_Vec V = *this;
-  V.coord.Divide (Scalar);
-  return V;
-}
-
-inline void gp_Vec::Cross (const gp_Vec& Right)
-{ coord.Cross (Right.coord); }
-
-inline gp_Vec gp_Vec::Crossed (const gp_Vec& Right) const
-{
-  gp_Vec V = *this;
-  V.coord.Cross (Right.coord);
-  return V;
-}
-
-inline Standard_Real gp_Vec::CrossMagnitude
-(const gp_Vec& Right) const
-{ return coord.CrossMagnitude (Right.coord); }
-
-inline Standard_Real gp_Vec::CrossSquareMagnitude
-(const gp_Vec& Right) const
-{ return coord.CrossSquareMagnitude (Right.coord); }
-
-inline void gp_Vec::CrossCross (const gp_Vec& V1,
-                               const gp_Vec& V2)
-{ coord.CrossCross(V1.coord, V2.coord); }
-
-inline gp_Vec gp_Vec::CrossCrossed (const gp_Vec& V1,
-                                   const gp_Vec& V2) const
-{
-  gp_Vec V = *this;
-  V.coord.CrossCross(V1.coord, V2.coord);
-  return V;
-}
-
-inline Standard_Real gp_Vec::Dot (const gp_Vec& Other) const
-{ return coord.Dot (Other.coord); }
-
-inline Standard_Real gp_Vec::DotCross (const gp_Vec& V1,
-                                      const gp_Vec& V2)  const
-{ return coord.DotCross (V1.coord, V2.coord); } 
-
-inline void gp_Vec::Normalize()
-{ 
-  Standard_Real D = coord.Modulus();
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
-                                       "gp_Vec::Normalize() - vector has zero norm");
-  coord.Divide (D);
-}
-
-inline gp_Vec gp_Vec::Normalized() const
-{ 
-  Standard_Real D = coord.Modulus();
-  Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
-                                       "gp_Vec::Normalized() - vector has zero norm");
-  gp_Vec V = *this;
-  V.coord.Divide (D);
-  return V; 
-}
-
-inline void gp_Vec::Reverse()
-{ coord.Reverse(); }
-
-inline gp_Vec gp_Vec::Reversed () const
-{
-  gp_Vec V = *this;
-  V.coord.Reverse();
-  return V;
-}
-
-inline void gp_Vec::SetLinearForm
-(const Standard_Real L,
- const gp_Vec& Left,
- const Standard_Real R,
- const gp_Vec& Right)
-{ coord.SetLinearForm (L, Left.coord, R, Right.coord); }
-
-inline void gp_Vec::SetLinearForm
-(const Standard_Real L,
- const gp_Vec& Left,
- const gp_Vec& Right)
-{ coord.SetLinearForm (L, Left.coord, Right.coord); }
-
-inline void gp_Vec::SetLinearForm
-(const gp_Vec& Left,
- const gp_Vec& Right)
-{ coord.SetLinearForm (Left.coord,  Right.coord); }
-
-inline void gp_Vec::SetLinearForm
-(const Standard_Real A1, const gp_Vec& V1, 
- const Standard_Real A2, const gp_Vec& V2,
- const Standard_Real A3, const gp_Vec& V3)
-{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, A3, V3.coord); }
-
-inline void gp_Vec::SetLinearForm
-(const Standard_Real A1, const gp_Vec& V1, 
- const Standard_Real A2, const gp_Vec& V2, 
- const gp_Vec& V3)
-{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }
-
-inline void gp_Vec::SetLinearForm
-(const Standard_Real A1, const gp_Vec& V1,
- const Standard_Real A2, const gp_Vec& V2,
- const Standard_Real A3, const gp_Vec& V3,
- const gp_Vec& V4)
-{ coord.SetLinearForm(A1,V1.coord,A2,V2.coord,A3,V3.coord,V4.coord); }
-
-inline void gp_Vec::Rotate (const gp_Ax1& A1,
-                           const Standard_Real Ang)
-{
-  gp_Trsf T;
-  T.SetRotation (A1, Ang);
-  coord.Multiply (T.VectorialPart());
-}
-
-inline gp_Vec gp_Vec::Rotated (const gp_Ax1& A1,
-                              const Standard_Real Ang) const
-{
-  gp_Vec Vres = *this;
-  Vres.Rotate (A1, Ang);
-  return Vres;                     
-}
-
-inline void gp_Vec::Scale (const Standard_Real S)
-{ coord.Multiply (S); }
-
-inline gp_Vec gp_Vec::Scaled (const Standard_Real S) const
-{
-  gp_Vec V = *this;
-  V.coord.Multiply(S);
-  return V;
-}
-
-inline gp_Vec gp_Vec::Transformed (const gp_Trsf& T) const
-{
-  gp_Vec V = *this;
-  V.Transform(T);
-  return V;
-} 
-
-inline gp_Vec operator* (const Standard_Real Scalar, const gp_Vec& V) {
- return V.Multiplied(Scalar);
-}
-