// Copyright (c) 1997-1999 Matra Datavision
// Copyright (c) 1999-2023 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.

#include <Standard_DimensionError.hxx>
#include <Standard_DivideByZero.hxx>
#include <Standard_RangeError.hxx>
#include <Standard_NullValue.hxx>

#include <stdio.h>

template <typename TheItemType>
math_VectorBase<TheItemType>::math_VectorBase(const Standard_Integer theLower,
                                              const Standard_Integer theUpper)
    : Array(*myBuffer.data(),
            theLower,
            theUpper,
            (theUpper - theLower + 1 <= math_VectorBase::THE_BUFFER_SIZE))
{
}

template <typename TheItemType>
math_VectorBase<TheItemType>::math_VectorBase(const Standard_Integer theLower,
                                              const Standard_Integer theUpper,
                                              const TheItemType      theInitialValue)
    : Array(*myBuffer.data(),
            theLower,
            theUpper,
            (theUpper - theLower + 1 <= math_VectorBase::THE_BUFFER_SIZE))
{
  Array.Init(theInitialValue);
}

template <typename TheItemType>
math_VectorBase<TheItemType>::math_VectorBase(const TheItemType*     theTab,
                                              const Standard_Integer theLower,
                                              const Standard_Integer theUpper)
    : Array(*theTab, theLower, theUpper)
{
}

template <typename TheItemType>
math_VectorBase<TheItemType>::math_VectorBase(const gp_XY& theOther)
    : Array(*myBuffer.data(), 1, 2)
{
  Array(1) = static_cast<TheItemType>(theOther.X());
  Array(2) = static_cast<TheItemType>(theOther.Y());
}

template <typename TheItemType>
math_VectorBase<TheItemType>::math_VectorBase(const gp_XYZ& theOther)
    : Array(*myBuffer.data(), 1, 3)
{
  Array(1) = static_cast<TheItemType>(theOther.X());
  Array(2) = static_cast<TheItemType>(theOther.Y());
  Array(3) = static_cast<TheItemType>(theOther.Z());
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Init(const TheItemType theInitialValue)
{
  Array.Init(theInitialValue);
}

template <typename TheItemType>
math_VectorBase<TheItemType>::math_VectorBase(const math_VectorBase<TheItemType>& theOther)
    : Array(theOther.Array)
{
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::SetLower(const Standard_Integer theLower)
{
  Array.UpdateLowerBound(theLower);
}

template <typename TheItemType>
Standard_Real math_VectorBase<TheItemType>::Norm() const
{
  Standard_Real Result = 0;
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Result = Result + Array(Index) * Array(Index);
  }
  return Sqrt(Result);
}

template <typename TheItemType>
Standard_Real math_VectorBase<TheItemType>::Norm2() const
{
  Standard_Real Result = 0;

  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Result = Result + Array(Index) * Array(Index);
  }
  return Result;
}

template <typename TheItemType>
Standard_Integer math_VectorBase<TheItemType>::Max() const
{
  Standard_Integer I = 0;
  Standard_Real    X = RealFirst();

  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    if (Array(Index) > X)
    {
      X = Array(Index);
      I = Index;
    }
  }
  return I;
}

template <typename TheItemType>
Standard_Integer math_VectorBase<TheItemType>::Min() const
{
  Standard_Integer I = 0;
  Standard_Real    X = RealLast();

  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    if (Array(Index) < X)
    {
      X = Array(Index);
      I = Index;
    }
  }
  return I;
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Set(const Standard_Integer              theI1,
                                       const Standard_Integer              theI2,
                                       const math_VectorBase<TheItemType>& theV)
{
  Standard_RangeError_Raise_if((theI1 < Lower()) || (theI2 > Upper()) || (theI1 > theI2)
                                 || (theI2 - theI1 + 1 != theV.Length()),
                               "math_VectorBase::Set() - invalid indices");
  Standard_Integer I = theV.Lower();
  for (Standard_Integer Index = theI1; Index <= theI2; Index++)
  {
    Array(Index) = theV.Array(I);
    I++;
  }
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Normalize()
{
  Standard_Real Result = Norm();
  Standard_NullValue_Raise_if((Result <= RealEpsilon()),
                              "math_VectorBase::Normalize() - vector has zero norm");
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Array(Index) = Array(Index) / Result;
  }
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Normalized() const
{
  math_VectorBase Result = *this;
  Result.Normalize();
  return Result;
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Invert()
{
  for (Standard_Integer Index = Lower(); Index <= (Lower() + Length()) >> 1; Index++)
  {
    Standard_Integer J     = Upper() + Lower() - Index;
    TheItemType      aTemp = Array(Index);
    Array(Index)           = Array(J);
    Array(J)               = aTemp;
  }
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Inverse() const
{
  math_VectorBase Result = *this;
  Result.Invert();
  return Result;
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Multiplied(
  const TheItemType theRight) const
{
  math_VectorBase Result(Lower(), Upper());
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Result.Array(Index) = Array(Index) * theRight;
  }
  return Result;
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::TMultiplied(
  const TheItemType theRight) const
{
  math_VectorBase Result(Lower(), Upper());
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Result.Array(Index) = Array(Index) * theRight;
  }
  return Result;
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Multiply(const TheItemType theRight)
{
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Array(Index) = Array(Index) * theRight;
  }
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Divide(const TheItemType theRight)
{
  Standard_DivideByZero_Raise_if(Abs(theRight) <= RealEpsilon(),
                                 "math_VectorBase::Divide() - devisor is zero");

  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Array(Index) = Array(Index) / theRight;
  }
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Divided(const TheItemType theRight) const
{
  Standard_DivideByZero_Raise_if(Abs(theRight) <= RealEpsilon(),
                                 "math_VectorBase::Divided() - devisor is zero");
  math_VectorBase temp = Multiplied(1. / theRight);
  return temp;
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Add(const math_VectorBase<TheItemType>& theRight)
{
  Standard_DimensionError_Raise_if(Length() != theRight.Length(),
                                   "math_VectorBase::Add() - input vector has wrong dimensions");

  Standard_Integer I = theRight.Lower();
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Array(Index) = Array(Index) + theRight.Array(I);
    I++;
  }
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Added(
  const math_VectorBase<TheItemType>& theRight) const
{
  Standard_DimensionError_Raise_if(Length() != theRight.Length(),
                                   "math_VectorBase::Added() - input vector has wrong dimensions");

  math_VectorBase Result(Lower(), Upper());

  Standard_Integer I = theRight.Lower();
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Result.Array(Index) = Array(Index) + theRight.Array(I);
    I++;
  }
  return Result;
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Subtract(const math_VectorBase<TheItemType>& theRight)
{
  Standard_DimensionError_Raise_if(
    Length() != theRight.Length(),
    "math_VectorBase::Subtract() - input vector has wrong dimensions");

  Standard_Integer I = theRight.Lower();
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Array(Index) = Array(Index) - theRight.Array(I);
    I++;
  }
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Subtracted(
  const math_VectorBase<TheItemType>& theRight) const
{
  Standard_DimensionError_Raise_if(
    Length() != theRight.Length(),
    "math_VectorBase::Subtracted() - input vector has wrong dimensions");

  math_VectorBase Result(Lower(), Upper());

  Standard_Integer I = theRight.Lower();
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Result.Array(Index) = Array(Index) - theRight.Array(I);
    I++;
  }
  return Result;
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Slice(const Standard_Integer theI1,
                                                                 const Standard_Integer theI2) const
{
  Standard_RangeError_Raise_if((theI1 < Lower()) || (theI1 > Upper()) || (theI2 < Lower())
                                 || (theI2 > Upper()),
                               "math_VectorBase::Slice() - invalid indices");

  if (theI2 >= theI1)
  {
    math_VectorBase Result(theI1, theI2);
    for (Standard_Integer Index = theI1; Index <= theI2; Index++)
    {
      Result.Array(Index) = Array(Index);
    }
    return Result;
  }
  else
  {
    math_VectorBase Result(theI2, theI1);
    for (Standard_Integer Index = theI1; Index >= theI2; Index--)
    {
      Result.Array(Index) = Array(Index);
    }
    return Result;
  }
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Add(const math_VectorBase<TheItemType>& theLeft,
                                       const math_VectorBase<TheItemType>& theRight)
{
  Standard_DimensionError_Raise_if((Length() != theRight.Length())
                                     || (theRight.Length() != theLeft.Length()),
                                   "math_VectorBase::Add() - input vectors have wrong dimensions");

  Standard_Integer I = theLeft.Lower();
  Standard_Integer J = theRight.Lower();
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Array(Index) = theLeft.Array(I) + theRight.Array(J);
    I++;
    J++;
  }
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Subtract(const math_VectorBase<TheItemType>& theLeft,
                                            const math_VectorBase<TheItemType>& theRight)
{
  Standard_DimensionError_Raise_if(
    (Length() != theRight.Length()) || (theRight.Length() != theLeft.Length()),
    "math_VectorBase::Subtract() - input vectors have wrong dimensions");

  Standard_Integer I = theLeft.Lower();
  Standard_Integer J = theRight.Lower();
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Array(Index) = theLeft.Array(I) - theRight.Array(J);
    I++;
    J++;
  }
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Multiply(const math_Matrix&                  theLeft,
                                            const math_VectorBase<TheItemType>& theRight)
{
  Standard_DimensionError_Raise_if(
    (Length() != theLeft.RowNumber()) || (theLeft.ColNumber() != theRight.Length()),
    "math_VectorBase::Multiply() - input matrix and /or vector have wrong dimensions");

  Standard_Integer Index = Lower();
  for (Standard_Integer I = theLeft.LowerRowIndex; I <= theLeft.UpperRowIndex; I++)
  {
    Array(Index)       = 0.0;
    Standard_Integer K = theRight.Lower();
    for (Standard_Integer J = theLeft.LowerColIndex; J <= theLeft.UpperColIndex; J++)
    {
      Array(Index) = Array(Index) + theLeft.Array(I, J) * theRight.Array(K);
      K++;
    }
    Index++;
  }
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Multiply(const math_VectorBase<TheItemType>& theLeft,
                                            const math_Matrix&                  theRight)
{
  Standard_DimensionError_Raise_if(
    (Length() != theRight.ColNumber()) || (theLeft.Length() != theRight.RowNumber()),
    "math_VectorBase::Multiply() - input matrix and /or vector have wrong dimensions");

  Standard_Integer Index = Lower();
  for (Standard_Integer J = theRight.LowerColIndex; J <= theRight.UpperColIndex; J++)
  {
    Array(Index)       = 0.0;
    Standard_Integer K = theLeft.Lower();
    for (Standard_Integer I = theRight.LowerRowIndex; I <= theRight.UpperRowIndex; I++)
    {
      Array(Index) = Array(Index) + theLeft.Array(K) * theRight.Array(I, J);
      K++;
    }
    Index++;
  }
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::TMultiply(const math_Matrix&                  theTLeft,
                                             const math_VectorBase<TheItemType>& theRight)
{
  Standard_DimensionError_Raise_if(
    (Length() != theTLeft.ColNumber()) || (theTLeft.RowNumber() != theRight.Length()),
    "math_VectorBase::TMultiply() - input matrix and /or vector have wrong dimensions");

  Standard_Integer Index = Lower();
  for (Standard_Integer I = theTLeft.LowerColIndex; I <= theTLeft.UpperColIndex; I++)
  {
    Array(Index)       = 0.0;
    Standard_Integer K = theRight.Lower();
    for (Standard_Integer J = theTLeft.LowerRowIndex; J <= theTLeft.UpperRowIndex; J++)
    {
      Array(Index) = Array(Index) + theTLeft.Array(J, I) * theRight.Array(K);
      K++;
    }
    Index++;
  }
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::TMultiply(const math_VectorBase<TheItemType>& theLeft,
                                             const math_Matrix&                  theTRight)
{
  Standard_DimensionError_Raise_if(
    (Length() != theTRight.RowNumber()) || (theLeft.Length() != theTRight.ColNumber()),
    "math_VectorBase::TMultiply() - input matrix and /or vector have wrong dimensions");

  Standard_Integer Index = Lower();
  for (Standard_Integer J = theTRight.LowerRowIndex; J <= theTRight.UpperRowIndex; J++)
  {
    Array(Index)       = 0.0;
    Standard_Integer K = theLeft.Lower();
    for (Standard_Integer I = theTRight.LowerColIndex; I <= theTRight.UpperColIndex; I++)
    {
      Array(Index) = Array(Index) + theLeft.Array(K) * theTRight.Array(J, I);
      K++;
    }
    Index++;
  }
}

template <typename TheItemType>
TheItemType math_VectorBase<TheItemType>::Multiplied(
  const math_VectorBase<TheItemType>& theRight) const
{
  Standard_Real Result = 0;

  Standard_DimensionError_Raise_if(
    Length() != theRight.Length(),
    "math_VectorBase::Multiplied() - input vector has wrong dimensions");

  Standard_Integer I = theRight.Lower();
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Result = Result + Array(Index) * theRight.Array(I);
    I++;
  }
  return Result;
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Opposite()
{
  math_VectorBase Result(Lower(), Upper());
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    Result.Array(Index) = -Array(Index);
  }
  return Result;
}

template <typename TheItemType>
math_VectorBase<TheItemType> math_VectorBase<TheItemType>::Multiplied(
  const math_Matrix& theRight) const
{
  Standard_DimensionError_Raise_if(
    Length() != theRight.RowNumber(),
    "math_VectorBase::Multiplied() - input matrix has wrong dimensions");

  math_VectorBase Result(theRight.LowerColIndex, theRight.UpperColIndex);
  for (Standard_Integer J2 = theRight.LowerColIndex; J2 <= theRight.UpperColIndex; J2++)
  {
    Result.Array(J2)       = 0.0;
    Standard_Integer theI2 = theRight.LowerRowIndex;
    for (Standard_Integer I = Lower(); I <= Upper(); I++)
    {
      Result.Array(J2) = Result.Array(J2) + Array(I) * theRight.Array(theI2, J2);
      theI2++;
    }
  }
  return Result;
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Multiply(const TheItemType                   theLeft,
                                            const math_VectorBase<TheItemType>& theRight)
{
  Standard_DimensionError_Raise_if(
    (Length() != theRight.Length()),
    "math_VectorBase::Multiply() - input vector has wrong dimensions");
  for (Standard_Integer I = Lower(); I <= Upper(); I++)
  {
    Array(I) = theLeft * theRight.Array(I);
  }
}

template <typename TheItemType>
math_VectorBase<TheItemType>& math_VectorBase<TheItemType>::Initialized(
  const math_VectorBase<TheItemType>& theOther)
{
  Standard_DimensionError_Raise_if(
    Length() != theOther.Length(),
    "math_VectorBase::Initialized() - input vector has wrong dimensions");
  memmove(&Array.ChangeFirst(), &theOther.Array.First(), sizeof(TheItemType) * Array.Length());
  return *this;
}

template <typename TheItemType>
void math_VectorBase<TheItemType>::Dump(Standard_OStream& theO) const
{
  theO << "math_Vector of Length = " << Length() << "\n";
  for (Standard_Integer Index = Lower(); Index <= Upper(); Index++)
  {
    theO << "math_Vector(" << Index << ") = " << Array(Index) << "\n";
  }
}