// File gp_Vec2d.lxx  , REG 27/10/90
// Modif JCV 08/01/91 modifs suite a la deuxieme revue de projet
// et introduction des classes XY, Mat2d + nouveau operateurs

#include <gp_Dir2d.hxx>
#include <gp_Trsf2d.hxx>
#include <gp_Pnt2d.hxx>

inline gp_Vec2d::gp_Vec2d()
{}

inline gp_Vec2d::gp_Vec2d (const gp_Dir2d& V)
{ coord = V.XY(); }

inline gp_Vec2d::gp_Vec2d (const gp_XY& Coord) : coord(Coord)
{}

inline gp_Vec2d::gp_Vec2d (const Standard_Real Xv,
			   const Standard_Real Yv) : coord (Xv, Yv)
{ }

inline gp_Vec2d::gp_Vec2d (const gp_Pnt2d& P1,
			   const gp_Pnt2d& P2)
{ coord = P2.XY().Subtracted (P1.XY()); }

inline void gp_Vec2d::SetCoord (const Standard_Integer Index,
				const Standard_Real Xi)
{ coord.SetCoord (Index, Xi); }

inline void gp_Vec2d::SetCoord (const Standard_Real Xv,
				const Standard_Real Yv)
{ coord.SetCoord (Xv, Yv); }

inline void gp_Vec2d::SetX (const Standard_Real X)
{ coord.SetX (X); }

inline void gp_Vec2d::SetY (const Standard_Real Y)
{ coord.SetY (Y); }

inline void gp_Vec2d::SetXY (const gp_XY& Coord)
{ coord = Coord; }

inline Standard_Real gp_Vec2d::Coord (const Standard_Integer Index) const
{ return coord.Coord(Index); }

inline void gp_Vec2d::Coord(Standard_Real& Xv,
			    Standard_Real& Yv) const
{ coord.Coord(Xv, Yv); }

inline Standard_Real gp_Vec2d::X() const
{ return coord.X(); }
     
inline Standard_Real gp_Vec2d::Y() const
{ return coord.Y(); }

inline  const gp_XY& gp_Vec2d::XY () const
{ return coord; }

inline Standard_Boolean gp_Vec2d::IsNormal
(const gp_Vec2d& Other, 
 const Standard_Real AngularTolerance) const
{
  Standard_Real Ang = Angle(Other);
  if (Ang < 0) Ang = - Ang;
  Ang = Standard_PI / 2.0 - Angle(Other);
  if (Ang < 0) Ang = - Ang;
  return  Ang <= AngularTolerance;
}    

inline Standard_Boolean gp_Vec2d::IsOpposite
(const gp_Vec2d& Other,
 const Standard_Real AngularTolerance) const
{
  Standard_Real Ang = Angle(Other);
  if (Ang < 0) Ang = - Ang;
  return Standard_PI - Ang <= AngularTolerance;
}    

inline Standard_Boolean gp_Vec2d::IsParallel
(const gp_Vec2d& Other,
 const Standard_Real AngularTolerance) const
{
  Standard_Real Ang = Angle(Other);
  if (Ang < 0) Ang = - Ang;
  return   Ang <= AngularTolerance || Standard_PI - Ang <= AngularTolerance;
}    

inline Standard_Real gp_Vec2d::Magnitude() const
{ return coord.Modulus(); }

inline Standard_Real gp_Vec2d::SquareMagnitude() const
{ return coord.SquareModulus(); }

inline void gp_Vec2d::Add (const gp_Vec2d& Other)
{ coord.Add (Other.coord); }

inline gp_Vec2d gp_Vec2d::Added (const gp_Vec2d& Other) const
{
  gp_Vec2d V = *this;
  V.coord.Add (Other.coord);
  return V;
}

inline Standard_Real gp_Vec2d::Crossed (const gp_Vec2d& Right) const
{ return coord.Crossed (Right.coord); }

inline Standard_Real gp_Vec2d::CrossMagnitude (const gp_Vec2d& Right) const
{ return coord.CrossMagnitude (Right.coord); }

inline Standard_Real gp_Vec2d::CrossSquareMagnitude
(const gp_Vec2d& Right) const
{ return coord.CrossSquareMagnitude (Right.coord); }

inline void gp_Vec2d::Divide (const Standard_Real Scalar)
{ coord.Divide (Scalar); }

inline gp_Vec2d gp_Vec2d::Divided (const Standard_Real Scalar) const
{
  gp_Vec2d V = *this;
  V.coord.Divide(Scalar);
  return V;
}

inline Standard_Real gp_Vec2d::Dot (const gp_Vec2d& Other) const
{ return coord.Dot (Other.coord); }

inline void gp_Vec2d::Multiply (const Standard_Real Scalar)
{ coord.Multiply (Scalar); }

inline gp_Vec2d gp_Vec2d::Multiplied (const Standard_Real Scalar) const
{
  gp_Vec2d V = *this;
  V.coord.Multiply(Scalar);
  return V;
}

inline void gp_Vec2d::Normalize()
{ 
  Standard_Real D = coord.Modulus();
  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "");
  coord.Divide (D);
}

inline gp_Vec2d gp_Vec2d::Normalized() const
{ 
  Standard_Real D = coord.Modulus();
  Standard_ConstructionError_Raise_if (D <= gp::Resolution(), "");
  gp_Vec2d V = *this;
  V.coord.Divide (D);
  return V; 
}

inline void gp_Vec2d::Reverse()
{ coord.Reverse(); }

inline gp_Vec2d gp_Vec2d::Reversed() const
{
  gp_Vec2d V = *this;
  V.coord.Reverse();
  return V;
}

inline void gp_Vec2d::Subtract (const gp_Vec2d& Right)
{ coord.Subtract (Right.coord); }

inline gp_Vec2d gp_Vec2d::Subtracted (const gp_Vec2d& Right) const
{
  gp_Vec2d V = *this;
  V.coord.Subtract (Right.coord);
  return V;
}

inline void gp_Vec2d::SetLinearForm (const Standard_Real L, 
				     const gp_Vec2d& Left,
				     const Standard_Real R,
				     const gp_Vec2d& Right)
{ coord.SetLinearForm (L, Left.coord, R, Right.coord); }

inline void gp_Vec2d::SetLinearForm (const Standard_Real L, 
				     const gp_Vec2d& Left,
				     const gp_Vec2d& Right)
{ coord.SetLinearForm (L, Left.coord, Right.coord); }

inline void gp_Vec2d::SetLinearForm (const gp_Vec2d& Left,
				     const gp_Vec2d& Right)
{ coord.SetLinearForm (Left.coord,  Right.coord); }

inline void gp_Vec2d::SetLinearForm (const Standard_Real A1, 
				     const gp_Vec2d& V1,
				     const Standard_Real A2, 
				     const gp_Vec2d& V2, 
				     const gp_Vec2d& V3)
{ coord.SetLinearForm (A1, V1.coord, A2, V2.coord, V3.coord); }

inline void gp_Vec2d::Rotate (const Standard_Real Ang)
{
  gp_Trsf2d T;
  T.SetRotation  (gp_Pnt2d (0.0, 0.0), Ang);
  coord.Multiply (T.VectorialPart ());
}

inline gp_Vec2d gp_Vec2d::Rotated (const Standard_Real Ang) const
{
  gp_Vec2d V = *this;
  V.Rotate (Ang);
  return V;
}

inline void gp_Vec2d::Scale (const Standard_Real S)
{ coord.Multiply (S); }

inline gp_Vec2d gp_Vec2d::Scaled (const Standard_Real S) const
{
  gp_Vec2d V = *this;
  V.coord.Multiply (S);
  return V;
}

inline gp_Vec2d gp_Vec2d::Transformed (const gp_Trsf2d& T) const
{
  gp_Vec2d V = *this;
  V.Transform(T);
  return V;
} 

inline gp_Vec2d operator* (const Standard_Real Scalar,
			   const gp_Vec2d& V)
{ return V.Multiplied(Scalar); }