// 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 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& theOther, 
 const Standard_Real theAngularTolerance) const
{
  const Standard_Real anAng = Abs(M_PI_2 - Abs(Angle(theOther)));
  return !(anAng > theAngularTolerance);
}    

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 M_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 || M_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(),
                                       "gp_Vec2d::Normalize() - vector has zero norm");
  coord.Divide (D);
}

inline gp_Vec2d gp_Vec2d::Normalized() const
{ 
  Standard_Real D = coord.Modulus();
  Standard_ConstructionError_Raise_if (D <= gp::Resolution(),
                                       "gp_Vec2d::Normalized() - vector has zero norm");
  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); }

inline gp_Vec2d gp_Vec2d::GetNormal() const
{
  return gp_Vec2d(this->Y(), (-1)*this->X());
}