mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-04 18:06:22 +03:00
a5a7b3185b
Update empty method guards to new style with regex (see PR). Used clang-format 18.1.8. New actions to validate code formatting is added. Update .clang-format with disabling of include sorting. It is temporary changes, then include will be sorted. Apply formatting for /src and /tools folder. The files with .hxx,.cxx,.lxx,.h,.pxx,.hpp,*.cpp extensions.
557 lines
17 KiB
Plaintext
557 lines
17 KiB
Plaintext
// 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";
|
|
}
|
|
}
|