OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0024547: Convertation of the generic classes to the non-generic (math).

Browse Source 
- class "math_DoubleTab" was converted to the non-generic class. Some changes were made in the class "math_Matrix". And some stylish changes were made.

- class "math_SingleTab" was converted to the non-generic template class. And classes "math_Vector" and "math_IntegerVector" converted to the non-cdl, because they use template class "math_Vector". Some stylish changes were made.
This commit is contained in:
dln 2014-01-21 12:15:53 +04:00 committed by apn
parent 8cb69787f2
commit 3b010a7435
19 changed files with 1232 additions and 1621 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/math/FILES
View File

@ -4,3 +4,8 @@ math_Memory.hxx
math_Recipes.hxx math_Recipes.hxx
math_GaussPoints.hxx math_GaussPoints.hxx
math_Kronrod.cxx math_Kronrod.cxx
math_Vector.hxx
math_Vector.cxx
math_IntegerVector.hxx
math_IntegerVector.cxx
math_SingleTab.hxx

12
src/math/math.cdl
View File

@ -41,8 +41,8 @@ is
exception SingularMatrix inherits Failure; exception SingularMatrix inherits Failure;
class Vector; imported Vector;
class IntegerVector; imported IntegerVector;
class Matrix; class Matrix;
deferred class Function; deferred class Function;
deferred class FunctionWithDerivative; deferred class FunctionWithDerivative;
@ -93,13 +93,7 @@ is
Array1OfValueAndWeight from math, Array1OfValueAndWeight from math,
CompareOfValueAndWeight from math); CompareOfValueAndWeight from math);
generic class SingleTab; class DoubleTab;
generic class DoubleTab;
--- Instantiate classes:
class SingleTabOfReal instantiates SingleTab(Real);
class SingleTabOfInteger instantiates SingleTab(Integer);
class DoubleTabOfReal instantiates DoubleTab(Real);
--- Gauss Points --- Gauss Points

10
src/math/math_DoubleTab.cdl
View File

@ -14,17 +14,17 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
generic class DoubleTab from math (Item as any) class DoubleTab from math
uses Address from Standard uses Address from Standard
is is
Create(LowerRow, UpperRow, LowerCol, UpperCol: Integer) Create(LowerRow, UpperRow, LowerCol, UpperCol: Integer)
returns DoubleTab; returns DoubleTab;
Create(Tab : Item; LowerRow, UpperRow, LowerCol, UpperCol: Integer) Create(Tab : Address; LowerRow, UpperRow, LowerCol, UpperCol: Integer)
returns DoubleTab; returns DoubleTab;
Init(me : in out; InitValue: Item) is static; Init(me : in out; InitValue: Real) is static;
Create(Other: DoubleTab) Create(Other: DoubleTab)
returns DoubleTab; returns DoubleTab;
@ -48,7 +48,7 @@ is
---C++: alias operator() ---C++: alias operator()
---C++: return & ---C++: return &
---C++: inline ---C++: inline
returns Item returns Real
is static; is static;
@ -62,7 +62,7 @@ fields
Addr : Address; Addr : Address;
AddrBuf : Address[32]; AddrBuf : Address[32];
Buf : Item[512]; Buf : Real[512];
isAddrAllocated: Boolean; isAddrAllocated: Boolean;
isAllocated : Boolean; isAllocated : Boolean;
LowR : Integer; LowR : Integer;

35
src/math/math_DoubleTab.gxx → src/math/math_DoubleTab.cxx
View File

@ -13,7 +13,7 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
// Lpa, le 7/02/92 // Lpa, le 7/02/92
#include <math_DoubleTab.ixx>
#include <math_Memory.hxx> #include <math_Memory.hxx>
#include <Standard_OutOfRange.hxx> #include <Standard_OutOfRange.hxx>
@ -28,13 +28,13 @@ void math_DoubleTab::Allocate()
Standard_Integer RowNumber = UppR - LowR + 1; Standard_Integer RowNumber = UppR - LowR + 1;
Standard_Integer ColNumber = UppC - LowC + 1; Standard_Integer ColNumber = UppC - LowC + 1;
Item** TheAddr = !isAddrAllocated? (Item**)&AddrBuf : Standard_Real** TheAddr = !isAddrAllocated? (Standard_Real**)&AddrBuf :
(Item**) Standard::Allocate(RowNumber * sizeof(Item*)); (Standard_Real**) Standard::Allocate(RowNumber * sizeof(Standard_Real*));
Item* Address; Standard_Real* Address;
if(isAllocated) if(isAllocated)
Address = (Item*) Standard::Allocate(RowNumber * ColNumber * sizeof(Item)); Address = (Standard_Real*) Standard::Allocate(RowNumber * ColNumber * sizeof(Standard_Real));
else else
Address = (Item*) Addr; Address = (Standard_Real*) Addr;
Address -= LowC; Address -= LowC;
for (Standard_Integer Index = 0; Index < RowNumber; Index++) { for (Standard_Integer Index = 0; Index < RowNumber; Index++) {
@ -61,13 +61,12 @@ math_DoubleTab::math_DoubleTab(const Standard_Integer LowerRow,
Allocate(); Allocate();
} }
math_DoubleTab::math_DoubleTab(const Standard_Address Tab,
math_DoubleTab::math_DoubleTab(const Item& Tab,
const Standard_Integer LowerRow, const Standard_Integer LowerRow,
const Standard_Integer UpperRow, const Standard_Integer UpperRow,
const Standard_Integer LowerCol, const Standard_Integer LowerCol,
const Standard_Integer UpperCol) : const Standard_Integer UpperCol) :
Addr((void *) &Tab), Addr(Tab),
isAddrAllocated(UpperRow - LowerRow + 1 > CARRAY_LENGTH(AddrBuf)), isAddrAllocated(UpperRow - LowerRow + 1 > CARRAY_LENGTH(AddrBuf)),
isAllocated(Standard_False), isAllocated(Standard_False),
LowR(LowerRow), LowR(LowerRow),
@ -78,17 +77,15 @@ math_DoubleTab::math_DoubleTab(const Item& Tab,
Allocate(); Allocate();
} }
void math_DoubleTab::Init(const Item& InitValue) void math_DoubleTab::Init(const Standard_Real InitValue)
{ {
for (Standard_Integer i = LowR; i <= UppR; i++) { for (Standard_Integer i = LowR; i <= UppR; i++) {
for (Standard_Integer j = LowC; j <= UppC; j++) { for (Standard_Integer j = LowC; j <= UppC; j++) {
((Item**) Addr)[i][j] = InitValue; ((Standard_Real**) Addr)[i][j] = InitValue;
} }
} }
} }
math_DoubleTab::math_DoubleTab(const math_DoubleTab& Other) : math_DoubleTab::math_DoubleTab(const math_DoubleTab& Other) :
Addr(Buf), Addr(Buf),
isAddrAllocated(Other.UppR - Other.LowR + 1 > CARRAY_LENGTH(AddrBuf)), isAddrAllocated(Other.UppR - Other.LowR + 1 > CARRAY_LENGTH(AddrBuf)),
@ -105,11 +102,10 @@ math_DoubleTab::math_DoubleTab(const math_DoubleTab& Other) :
Standard_Address source = (Standard_Address) &Other.Value(LowR,LowC); Standard_Address source = (Standard_Address) &Other.Value(LowR,LowC);
memmove(target,source, memmove(target,source,
(int)((UppR - LowR + 1) * (UppC - LowC + 1) * sizeof(Item))); (int)((UppR - LowR + 1) * (UppC - LowC + 1) * sizeof(Standard_Real)));
} }
void math_DoubleTab::Free() void math_DoubleTab::Free()
{ {
// free the data // free the data
@ -119,26 +115,23 @@ void math_DoubleTab::Free()
} }
// free the pointers // free the pointers
if(isAddrAllocated) { if(isAddrAllocated) {
Standard_Address it = (Standard_Address)(((Item**)Addr) + LowR); Standard_Address it = (Standard_Address)(((Standard_Real**)Addr) + LowR);
Standard::Free (it); Standard::Free (it);
} }
Addr = 0; Addr = 0;
} }
void math_DoubleTab::SetLowerRow(const Standard_Integer LowerRow) void math_DoubleTab::SetLowerRow(const Standard_Integer LowerRow)
{ {
Item** TheAddr = (Item**)Addr; Standard_Real** TheAddr = (Standard_Real**)Addr;
Addr = (Standard_Address) (TheAddr + LowR - LowerRow); Addr = (Standard_Address) (TheAddr + LowR - LowerRow);
UppR = UppR - LowR + LowerRow; UppR = UppR - LowR + LowerRow;
LowR = LowerRow; LowR = LowerRow;
} }
void math_DoubleTab::SetLowerCol(const Standard_Integer LowerCol) void math_DoubleTab::SetLowerCol(const Standard_Integer LowerCol)
{ {
Item** TheAddr = (Item**) Addr; Standard_Real** TheAddr = (Standard_Real**) Addr;
for (Standard_Integer Index = LowR; Index <= UppR; Index++) { for (Standard_Integer Index = LowR; Index <= UppR; Index++) {
TheAddr[Index] = TheAddr[Index] + LowC - LowerCol; TheAddr[Index] = TheAddr[Index] + LowC - LowerCol;
} }

6
src/math/math_DoubleTab.lxx
View File

@ -17,10 +17,10 @@
#include <math_Memory.hxx> #include <math_Memory.hxx>
#include <Standard_OutOfRange.hxx> #include <Standard_OutOfRange.hxx>
inline Item& math_DoubleTab::Value (const Standard_Integer RowIndex, inline Standard_Real& math_DoubleTab::Value (const Standard_Integer RowIndex,
const Standard_Integer ColIndex) const const Standard_Integer ColIndex) const
{ {
return ((Item**)Addr)[RowIndex][ColIndex]; return ((Standard_Real**)Addr)[RowIndex][ColIndex];
} }
@ -29,7 +29,7 @@ inline void math_DoubleTab::Copy(math_DoubleTab& Other)const
{ {
memmove((void*)(& Other.Value(Other.LowR,Other.LowC)), memmove((void*)(& Other.Value(Other.LowR,Other.LowC)),
(void*) (& Value(LowR,LowC)), (void*) (& Value(LowR,LowC)),
(int)((UppR - LowR + 1) * (UppC - LowC + 1) * sizeof(Item))); (int)((UppR - LowR + 1) * (UppC - LowC + 1) * sizeof(Standard_Real)));
} }

334
src/math/math_IntegerVector.cdl
View File

@ -1,334 +0,0 @@
-- Created on: 1991-05-06
-- Created by: Laurent PAINNOT
-- Copyright (c) 1991-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 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.
class IntegerVector from math
---Purpose:
-- This class implements the real IntegerVector abstract data type.
-- IntegerVectors can have an arbitrary range which must be define at
-- the declaration and cannot be changed after this declaration.
-- Example: math_IntegerVector V1(-3, 5); // an IntegerVector with
-- range [-3..5]
--
-- IntegerVector is copied through assignement :
-- math_IntegerVector V2( 1, 9);
-- ....
-- V2 = V1;
-- V1(1) = 2.0; // the IntegerVector V2 will not be modified.
--
-- The Exception RangeError is raised when trying to access outside
-- the range of an IntegerVector :
-- V1(11) = 0 // --> will raise RangeError;
--
-- The Exception DimensionError is raised when the dimensions of two
-- IntegerVectors are not compatible :
-- math_IntegerVector V3(1, 2);
-- V3 = V1; // --> will raise DimensionError;
-- V1.Add(V3) // --> will raise DimensionError;
uses Matrix from math,
SingleTabOfInteger from math,
OStream from Standard
raises DimensionError from Standard,
DivideByZero from Standard,
RangeError from Standard
is
Create(First, Last: Integer)
---Purpose: contructs an IntegerVector in the range [Lower..Upper]
returns IntegerVector;
Create(First, Last: Integer; InitialValue : Integer)
---Purpose: contructs an IntegerVector in the range [Lower..Upper]
-- with all the elements set to InitialValue.
returns IntegerVector;
Init(me : in out; InitialValue: Integer);
---Purpose: Initialize an IntegerVector with all the elements
-- set to InitialValue.
Create(Tab : Address; First, Last: Integer)
---Purpose: constructs an IntegerVector in the range [Lower..Upper]
-- which share the "c array" Tab.
returns IntegerVector;
Create(Other: IntegerVector)
---Purpose: constructs a copy for initialization.
-- An exception is raised if the lengths of the IntegerVectors
-- are different.
returns IntegerVector
raises DimensionError;
SetFirst(me: in out; First: Integer)
---Purpose: is used internally to set the Lower value of the
-- IntegerVector.
is static protected;
Length(me)
---Purpose: returns the length of an IntegerVector
---C++: inline
returns Integer
is static;
Lower(me)
---Purpose: returns the value of the Lower index of an IntegerVector.
---C++: inline
returns Integer
is static;
Upper(me)
---Purpose: returns the value of the Upper index of an IntegerVector.
---C++: inline
returns Integer
is static;
Norm(me)
---Purpose: returns the value of the norm of an IntegerVector.
returns Real
is static;
Norm2 (me)
---Purpose: returns the value of the square of the norm of an
-- IntegerVector.
returns Real
is static;
Max(me)
---Purpose: returns the value of the Index of the maximum element of
-- an IntegerVector.
returns Integer
is static;
Min(me)
---Purpose: returns the value of the Index of the minimum element
-- of an IntegerVector.
returns Integer
is static;
Invert(me: in out)
---Purpose: inverses an IntegerVector.
---Example: [1, 2, 3, 4] becomes [4, 3, 2, 1].
is static;
Inverse(me)
---Purpose: returns the inverse IntegerVector of an IntegerVector.
returns IntegerVector
is static;
Set(me: in out; I1, I2: Integer; V: IntegerVector)
---Purpose: sets an IntegerVector from <I1> to <I2> to the
-- IntegerVector <V>;
-- An exception is raised if I1<LowerIndex or I2>UpperIndex or I1>I2.
-- An exception is raised if I2-I1+1 is different from the Length of V.
raises DimensionError
is static;
Slice(me; I1, I2: Integer)
---Purpose: slices the values of the IntegerVector between <I1> and
-- <I2>:
-- Example: [2, 1, 2, 3, 4, 5] becomes [2, 4, 3, 2, 1, 5] between 2 and 5.
-- An exception is raised if I1<LowerIndex or I2>UpperIndex.
returns IntegerVector
raises DimensionError
is static;
Multiply (me: in out; Right: Integer)
---Purpose: returns the product of an IntegerVector by an integer value.
---C++: alias operator *=
raises DimensionError from Standard
is static;
Multiplied (me; Right: Integer)
---Purpose: returns the product of an IntegerVector by an integer value.
---C++: alias operator*
returns IntegerVector
raises DimensionError from Standard
is static;
TMultiplied (me; Right: Integer)
---Purpose: returns the product of a vector and a real value.
---C++: alias "friend math_IntegerVector operator *(const Standard_Integer Left,const math_IntegerVector& Right);"
returns IntegerVector
is static;
Add (me: in out; Right: IntegerVector)
---Purpose: adds the IntegerVector <Right> to an IntegerVector.
-- An exception is raised if the IntegerVectors have not the same
-- length.
-- An exception is raised if the lengths are not equal.
---C++: alias operator +=
raises DimensionError
is static;
Added (me; Right: IntegerVector)
---Purpose: adds the IntegerVector <Right> to an IntegerVector.
-- An exception is raised if the IntegerVectors have not the same
-- length.
-- An exception is raised if the lengths are not equal.
---C++:alias operator+
returns IntegerVector
raises DimensionError
is static;
Add (me: in out; Left, Right: IntegerVector)
---Purpose: sets an IntegerVector to the sum of the IntegerVector
-- <Left> and the IntegerVector <Right>.
-- An exception is raised if the lengths are different.
raises DimensionError
is static;
Subtract(me: in out; Left, Right: IntegerVector)
---Purpose: sets an IntegerVector to the substraction of
-- <Right> from <Left>.
-- An exception is raised if the IntegerVectors have not the same
-- length.
raises DimensionError
is static;
Value(me; Num: Integer)
---Purpose: accesses (in read or write mode) the value of index Num of
-- an IntegerVector.
---C++: alias operator()
---C++: return &
---C++: inline
returns Integer
raises RangeError from Standard
is static;
Initialized(me: in out; Other: IntegerVector)
---Purpose: Initialises an IntegerVector by copying <Other>.
-- An exception is raised if the Lengths are different.
---C++: alias operator=
---C++: return &
returns IntegerVector
raises DimensionError
is static;
Multiplied(me; Right: IntegerVector)
---Purpose: returns the inner product of 2 IntegerVectors.
-- An exception is raised if the lengths are not equal.
---C++: alias operator*
returns Integer
raises DimensionError
is static;
Opposite(me: in out)
---Purpose: returns the opposite of an IntegerVector.
---C++: alias operator-
returns IntegerVector
is static;
Subtract(me: in out; Right: IntegerVector)
---Purpose: returns the subtraction of <Right> from <me>.
-- An exception is raised if the IntegerVectors have not the same length.
---C++: alias operator-=
raises DimensionError
is static;
Subtracted(me; Right: IntegerVector)
---Purpose: returns the subtraction of <Right> from <me>.
-- An exception is raised if the IntegerVectors have not the same length.
---C++: alias operator-
returns IntegerVector
raises DimensionError
is static;
Multiply(me: in out; Left: Integer; Right: IntegerVector)
---Purpose: returns the multiplication of an integer by an
-- IntegerVector.
raises DimensionError
is static;
Dump(me; o: in out OStream)
---Purpose: Prints on the stream o information on the current state
-- of the object.
-- Is used to redefine the operator <<.
is static;
fields
FirstIndex: Integer;
LastIndex: Integer;
Array: SingleTabOfInteger;
friends
class Matrix from math
end IntegerVector;

446
src/math/math_IntegerVector.cxx
View File

@ -12,97 +12,91 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
//#ifndef DEB
#define No_Standard_RangeError #define No_Standard_RangeError
#define No_Standard_OutOfRange #define No_Standard_OutOfRange
#define No_Standard_DimensionError #define No_Standard_DimensionError
//#endif
#include <math_IntegerVector.ixx> #include <math_IntegerVector.hxx>
#include <Standard_DimensionError.hxx> #include <Standard_DimensionError.hxx>
#include <Standard_RangeError.hxx> #include <Standard_RangeError.hxx>
math_IntegerVector::math_IntegerVector(const Standard_Integer theFirst, const Standard_Integer theLast) :
FirstIndex(theFirst),
math_IntegerVector::math_IntegerVector(const Standard_Integer First, LastIndex(theLast),
const Standard_Integer Last): Array(theFirst, theLast)
FirstIndex(First),
LastIndex(Last),
Array(First, Last) {
Standard_RangeError_Raise_if(First > Last, " ");
}
math_IntegerVector::math_IntegerVector(const Standard_Integer First,
const Standard_Integer Last,
const Standard_Integer InitialValue):
FirstIndex(First),
LastIndex(Last),
Array(First, Last) {
Standard_RangeError_Raise_if(First > Last, " ");
Array.Init(InitialValue);
}
math_IntegerVector::math_IntegerVector(const Standard_Address Tab,
const Standard_Integer First,
const Standard_Integer Last) :
FirstIndex(First),
LastIndex(Last),
Array(*((const Standard_Integer *)Tab),
First, Last)
{ {
Standard_RangeError_Raise_if(First > Last, " "); Standard_RangeError_Raise_if(theFirst > theLast, " ");
} }
math_IntegerVector::math_IntegerVector(const Standard_Integer theFirst,
void math_IntegerVector::Init(const Standard_Integer InitialValue) const Standard_Integer theLast,
const Standard_Integer theInitialValue) :
FirstIndex(theFirst),
LastIndex(theLast),
Array(theFirst, theLast)
{ {
Array.Init(InitialValue); Standard_RangeError_Raise_if(theFirst > theLast, " ");
Array.Init(theInitialValue);
} }
math_IntegerVector::math_IntegerVector(const Standard_Address theTab,
math_IntegerVector::math_IntegerVector(const math_IntegerVector& Other): const Standard_Integer theFirst,
const Standard_Integer theLast) :
FirstIndex(Other.FirstIndex), FirstIndex(theFirst),
LastIndex(Other.LastIndex), LastIndex(theLast),
Array(Other.Array) {} Array(theTab, theFirst, theLast)
{
Standard_RangeError_Raise_if(theFirst > theLast, " ");
void math_IntegerVector::SetFirst(const Standard_Integer First) {
Array.SetLower(First);
LastIndex = LastIndex - FirstIndex + First;
FirstIndex = First;
} }
void math_IntegerVector::Init(const Standard_Integer theInitialValue)
{
Array.Init(theInitialValue);
}
Standard_Real math_IntegerVector::Norm() const { math_IntegerVector::math_IntegerVector(const math_IntegerVector& theOther) :
FirstIndex(theOther.FirstIndex),
LastIndex(theOther.LastIndex),
Array(theOther.Array)
{
}
void math_IntegerVector::SetFirst(const Standard_Integer theFirst)
{
Array.SetLower(theFirst);
LastIndex = LastIndex - FirstIndex + theFirst;
FirstIndex = theFirst;
}
Standard_Real math_IntegerVector::Norm() const
{
Standard_Real Result = 0; Standard_Real Result = 0;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
{
Result = Result + Array(Index) * Array(Index); Result = Result + Array(Index) * Array(Index);
} }
return Sqrt(Result); return Sqrt(Result);
} }
Standard_Real math_IntegerVector::Norm2() const
Standard_Real math_IntegerVector::Norm2() const { {
Standard_Real Result = 0; Standard_Real Result = 0;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
{
Result = Result + Array(Index) * Array(Index); Result = Result + Array(Index) * Array(Index);
} }
return Result; return Result;
} }
Standard_Integer math_IntegerVector::Max() const
Standard_Integer math_IntegerVector::Max() const { {
Standard_Integer I=0; Standard_Integer I=0;
Standard_Real X = RealFirst(); Standard_Real X = RealFirst();
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
if(Array(Index) > X) { {
if(Array(Index) > X)
{
X = Array(Index); X = Array(Index);
I = Index; I = Index;
} }
@ -110,12 +104,14 @@ Standard_Integer math_IntegerVector::Max() const {
return I; return I;
} }
Standard_Integer math_IntegerVector::Min() const
Standard_Integer math_IntegerVector::Min() const { {
Standard_Integer I=0; Standard_Integer I=0;
Standard_Real X = RealLast(); Standard_Real X = RealLast();
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
if(Array(Index) < X) { {
if(Array(Index) < X)
{
X = Array(Index); X = Array(Index);
I = Index; I = Index;
} }
@ -123,241 +119,231 @@ Standard_Integer math_IntegerVector::Min() const {
return I; return I;
} }
void math_IntegerVector::Invert()
void math_IntegerVector::Invert() { {
Standard_Integer J; Standard_Integer J;
Standard_Integer Temp; Standard_Integer Temp;
for(Standard_Integer Index = FirstIndex; for(Standard_Integer Index = FirstIndex; Index <= FirstIndex + Length() / 2 ; Index++)
Index <= FirstIndex + Length() / 2 ; Index++) { {
J = LastIndex + FirstIndex - Index; J = LastIndex + FirstIndex - Index;
Temp = Array(Index); Temp = Array(Index);
Array(Index) = Array(J); Array(Index) = Array(J);
Array(J) = Temp; Array(J) = Temp;
} }
} }
math_IntegerVector math_IntegerVector::Inverse() const
math_IntegerVector math_IntegerVector::Inverse() const { {
math_IntegerVector Result = *this; math_IntegerVector Result = *this;
Result.Invert(); Result.Invert();
return Result; return Result;
} }
void math_IntegerVector::Set(const Standard_Integer theI1,
const Standard_Integer theI2,
const math_IntegerVector &theV)
{
Standard_DimensionError_Raise_if((theI1 < FirstIndex) || (theI2 > LastIndex) ||
(theI1 > theI2) || (theI2 - theI1 + 1 != theV.Length()), " ");
void math_IntegerVector::Set(const Standard_Integer I1, Standard_Integer I = theV.Lower();
const Standard_Integer I2, for(Standard_Integer Index = theI1; Index <= theI2; Index++)
const math_IntegerVector &V) { {
Array(Index) = theV.Array(I);
Standard_DimensionError_Raise_if((I1 < FirstIndex) ||
(I2 > LastIndex) ||
(I1 > I2) ||
(I2 - I1 + 1 != V.Length()), " ");
Standard_Integer I = V.Lower();
for(Standard_Integer Index = I1; Index <= I2; Index++) {
Array(Index) = V.Array(I);
I++; I++;
} }
} }
void math_IntegerVector::Multiply(const Standard_Integer theRight)
void math_IntegerVector::Multiply(const Standard_Integer Right) { {
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { {
Array(Index) = Array(Index) * Right; Array(Index) = Array(Index) * theRight;
} }
} }
void math_IntegerVector::Add(const math_IntegerVector& theRight)
{
Standard_DimensionError_Raise_if(Length() != theRight.Length(), " ");
void math_IntegerVector::Add(const math_IntegerVector& Right) { Standard_Integer I = theRight.FirstIndex;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
Standard_DimensionError_Raise_if(Length() != Right.Length(), " "); {
Array(Index) = Array(Index) + theRight.Array(I);
Standard_Integer I = Right.FirstIndex;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) {
Array(Index) = Array(Index) + Right.Array(I);
I++; I++;
} }
} }
void math_IntegerVector::Subtract(const math_IntegerVector& theRight)
void math_IntegerVector::Subtract(const math_IntegerVector& Right) { {
Standard_DimensionError_Raise_if(Length() != theRight.Length(), " ");
Standard_DimensionError_Raise_if(Length() != Right.Length(), " "); Standard_Integer I = theRight.FirstIndex;
Standard_Integer I = Right.FirstIndex; for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { {
Array(Index) = Array(Index) - Right.Array(I); Array(Index) = Array(Index) - theRight.Array(I);
I++; I++;
} }
} }
math_IntegerVector math_IntegerVector::Slice(const Standard_Integer theI1,
const Standard_Integer theI2) const
{
Standard_DimensionError_Raise_if((theI1 < FirstIndex) || (theI1 > LastIndex) ||
(theI2 < FirstIndex) || (theI2 > LastIndex), " ");
math_IntegerVector math_IntegerVector::Slice(const Standard_Integer I1, if(theI2 >= theI1)
const Standard_Integer I2) const { {
math_IntegerVector Result(theI1, theI2);
Standard_DimensionError_Raise_if((I1 < FirstIndex) || (I1 > LastIndex) || for(Standard_Integer Index = theI1; Index <= theI2; Index++)
(I2 < FirstIndex) || (I2 > LastIndex), {
" ");
if(I2 >= I1) {
math_IntegerVector Result(I1, I2);
for(Standard_Integer Index = I1; Index <= I2; Index++) {
Result.Array(Index) = Array(Index);
}
return Result;
}
else {
math_IntegerVector Result(I2, I1);
for(Standard_Integer Index = I1; Index >= I2; Index--) {
Result.Array(Index) = Array(Index); Result.Array(Index) = Array(Index);
} }
return Result; return Result;
} }
else
{
math_IntegerVector Result(theI2, theI1);
for(Standard_Integer Index = theI1; Index >= theI2; Index--)
{
Result.Array(Index) = Array(Index);
}
return Result;
}
} }
Standard_Integer math_IntegerVector::Multiplied (const math_IntegerVector& Right) const { Standard_Integer math_IntegerVector::Multiplied (const math_IntegerVector& theRight) const
{
Standard_Integer Result = 0; Standard_Integer Result = 0;
Standard_DimensionError_Raise_if(Length() != Right.Length(), " ");
Standard_Integer I = Right.FirstIndex; Standard_DimensionError_Raise_if(Length() != theRight.Length(), " ");
for(Standard_Integer Index = 0; Index < Length(); Index++) {
Result = Result + Array(Index) * Right.Array(I); Standard_Integer I = theRight.FirstIndex;
for(Standard_Integer Index = 0; Index < Length(); Index++)
{
Result = Result + Array(Index) * theRight.Array(I);
I++; I++;
} }
return Result; return Result;
} }
math_IntegerVector math_IntegerVector::Multiplied (const Standard_Integer theRight)const
math_IntegerVector math_IntegerVector::Multiplied (const Standard_Integer Right)const { {
math_IntegerVector Result(FirstIndex, LastIndex); math_IntegerVector Result(FirstIndex, LastIndex);
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
Result.Array(Index) = Array(Index) * Right; {
Result.Array(Index) = Array(Index) * theRight;
} }
return Result; return Result;
} }
math_IntegerVector math_IntegerVector::TMultiplied (const Standard_Integer Right)const { math_IntegerVector math_IntegerVector::TMultiplied (const Standard_Integer theRight) const
{
math_IntegerVector Result(FirstIndex, LastIndex); math_IntegerVector Result(FirstIndex, LastIndex);
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
Result.Array(Index) = Array(Index) * Right; {
Result.Array(Index) = Array(Index) * theRight;
} }
return Result; return Result;
} }
math_IntegerVector math_IntegerVector::Added (const math_IntegerVector& theRight) const
{
Standard_DimensionError_Raise_if(Length() != theRight.Length(), " ");
math_IntegerVector math_IntegerVector::Added (const math_IntegerVector& Right) const {
Standard_DimensionError_Raise_if(Length() != Right.Length(), " ");
math_IntegerVector Result(FirstIndex, LastIndex); math_IntegerVector Result(FirstIndex, LastIndex);
Standard_Integer I = Right.FirstIndex; Standard_Integer I = theRight.FirstIndex;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
Result.Array(Index) = Array(Index) + Right.Array(I); {
Result.Array(Index) = Array(Index) + theRight.Array(I);
I++; I++;
} }
return Result; return Result;
} }
math_IntegerVector math_IntegerVector::Opposite()
{
math_IntegerVector math_IntegerVector::Opposite() {
math_IntegerVector Result(FirstIndex, LastIndex); math_IntegerVector Result(FirstIndex, LastIndex);
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
{
Result.Array(Index) = - Array(Index); Result.Array(Index) = - Array(Index);
} }
return Result; return Result;
} }
math_IntegerVector math_IntegerVector::Subtracted (const math_IntegerVector& theRight) const
{
Standard_DimensionError_Raise_if(Length() != theRight.Length(), " ");
math_IntegerVector math_IntegerVector::Subtracted (const math_IntegerVector& Right) const {
Standard_DimensionError_Raise_if(Length() != Right.Length(), " ");
math_IntegerVector Result(FirstIndex, LastIndex); math_IntegerVector Result(FirstIndex, LastIndex);
Standard_Integer I = Right.FirstIndex; Standard_Integer I = theRight.FirstIndex;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
Result.Array(Index) = Array(Index) - Right.Array(I); {
Result.Array(Index) = Array(Index) - theRight.Array(I);
I++; I++;
} }
return Result; return Result;
} }
void math_IntegerVector::Add (const math_IntegerVector& Left,
const math_IntegerVector& Right) {
Standard_DimensionError_Raise_if((Length() != Right.Length()) ||
(Right.Length() != Left.Length()), " ");
Standard_Integer I = Left.FirstIndex; void math_IntegerVector::Add (const math_IntegerVector& theLeft, const math_IntegerVector& theRight)
Standard_Integer J = Right.FirstIndex;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) {
Array(Index) = Left.Array(I) + Right.Array(J);
I++;
J++;
}
}
void math_IntegerVector::Subtract (const math_IntegerVector& Left,
const math_IntegerVector& Right) {
Standard_DimensionError_Raise_if((Length() != Right.Length()) ||
(Right.Length() != Left.Length()), " ");
Standard_Integer I = Left.FirstIndex;
Standard_Integer J = Right.FirstIndex;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) {
Array(Index) = Left.Array(I) - Right.Array(J);
I++;
J++;
}
}
void math_IntegerVector::Multiply(const Standard_Integer Left,
const math_IntegerVector& Right)
{ {
Standard_DimensionError_Raise_if((Length() != Right.Length()), Standard_DimensionError_Raise_if((Length() != theRight.Length()) ||
" "); (theRight.Length() != theLeft.Length()), " ");
for(Standard_Integer I = FirstIndex; I <= LastIndex; I++) {
Array(I) = Left * Right.Array(I); Standard_Integer I = theLeft.FirstIndex;
Standard_Integer J = theRight.FirstIndex;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
{
Array(Index) = theLeft.Array(I) + theRight.Array(J);
I++;
J++;
} }
} }
void math_IntegerVector::Subtract (const math_IntegerVector& theLeft,
const math_IntegerVector& theRight)
{
Standard_DimensionError_Raise_if((Length() != theRight.Length()) ||
(theRight.Length() != theLeft.Length()), " ");
math_IntegerVector& math_IntegerVector::Initialized (const math_IntegerVector& Other) { Standard_Integer I = theLeft.FirstIndex;
Standard_Integer J = theRight.FirstIndex;
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
{
Array(Index) = theLeft.Array(I) - theRight.Array(J);
I++;
J++;
}
}
Standard_DimensionError_Raise_if(Length() != Other.Length(), " "); void math_IntegerVector::Multiply(const Standard_Integer theLeft, const math_IntegerVector& theRight)
{
Standard_DimensionError_Raise_if((Length() != theRight.Length()), " ");
for(Standard_Integer I = FirstIndex; I <= LastIndex; I++)
{
Array(I) = theLeft * theRight.Array(I);
}
}
(Other.Array).Copy(Array); math_IntegerVector& math_IntegerVector::Initialized(const math_IntegerVector& theOther)
{
Standard_DimensionError_Raise_if(Length() != theOther.Length(), " ");
(theOther.Array).Copy(Array);
return *this; return *this;
} }
void math_IntegerVector::Dump(Standard_OStream& theO) const
void math_IntegerVector::Dump(Standard_OStream& o) const
{ {
o << "math_IntegerVector of Range = " << Length() << "\n"; theO << "math_IntegerVector of Range = " << Length() << "\n";
for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++) { for(Standard_Integer Index = FirstIndex; Index <= LastIndex; Index++)
o << "math_IntegerVector(" << Index << ") = " << Array(Index) << "\n"; {
} theO << "math_IntegerVector(" << Index << ") = " << Array(Index) << "\n";
}
} }

261
src/math/math_IntegerVector.hxx Normal file
View File

@ -0,0 +1,261 @@
// Copyright (c) 1997-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 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.
#ifndef _math_IntegerVector_HeaderFile
#define _math_IntegerVector_HeaderFile
#include <math_SingleTab.hxx>
class Standard_DimensionError;
class Standard_DivideByZero;
class Standard_RangeError;
class math_Matrix;
//! This class implements the real IntegerVector abstract data type.
//! IntegerVectors can have an arbitrary range which must be define at
//! the declaration and cannot be changed after this declaration.
//! Example:
//! @code
//! math_IntegerVector V1(-3, 5); // an IntegerVector with range [-3..5]
//! @endcode
//!
//! IntegerVector is copied through assignement :
//! @code
//! math_IntegerVector V2( 1, 9);
//! ....
//! V2 = V1;
//! V1(1) = 2.0; // the IntegerVector V2 will not be modified.
//! @endcode
//!
//! The Exception RangeError is raised when trying to access outside
//! the range of an IntegerVector :
//! @code
//! V1(11) = 0 // --> will raise RangeError;
//! @endcode
//!
//! The Exception DimensionError is raised when the dimensions of two
//! IntegerVectors are not compatible :
//! @code
//! math_IntegerVector V3(1, 2);
//! V3 = V1; // --> will raise DimensionError;
//! V1.Add(V3) // --> will raise DimensionError;
//! @endcode
class math_IntegerVector
{
public:
DEFINE_STANDARD_ALLOC
//! contructs an IntegerVector in the range [Lower..Upper]
Standard_EXPORT math_IntegerVector(const Standard_Integer theFirst, const Standard_Integer theLast);
//! contructs an IntegerVector in the range [Lower..Upper]
//! with all the elements set to theInitialValue.
Standard_EXPORT math_IntegerVector(const Standard_Integer theFirst, const Standard_Integer theLast, const Standard_Integer theInitialValue);
//! Initialize an IntegerVector with all the elements
//! set to theInitialValue.
Standard_EXPORT void Init(const Standard_Integer theInitialValue);
//! constructs an IntegerVector in the range [Lower..Upper]
//! which share the "c array" theTab.
Standard_EXPORT math_IntegerVector(const Standard_Address theTab, const Standard_Integer theFirst, const Standard_Integer theLast);
//! constructs a copy for initialization.
//! An exception is raised if the lengths of the IntegerVectors
//! are different.
Standard_EXPORT math_IntegerVector(const math_IntegerVector& theOther);
//! returns the length of an IntegerVector
inline Standard_Integer Length() const
{
return LastIndex - FirstIndex +1;
}
//! returns the value of the Lower index of an IntegerVector.
inline Standard_Integer Lower() const
{
return FirstIndex;
}
//! returns the value of the Upper index of an IntegerVector.
inline Standard_Integer Upper() const
{
return LastIndex;
}
//! returns the value of the norm of an IntegerVector.
Standard_EXPORT Standard_Real Norm() const;
//! returns the value of the square of the norm of an IntegerVector.
Standard_EXPORT Standard_Real Norm2() const;
//! returns the value of the Index of the maximum element of an IntegerVector.
Standard_EXPORT Standard_Integer Max() const;
//! returns the value of the Index of the minimum element of an IntegerVector.
Standard_EXPORT Standard_Integer Min() const;
//! inverses an IntegerVector.
Standard_EXPORT void Invert();
//! returns the inverse IntegerVector of an IntegerVector.
Standard_EXPORT math_IntegerVector Inverse() const;
//! sets an IntegerVector from "theI1" to "theI2" to the IntegerVector "theV";
//! An exception is raised if "theI1" is less than "LowerIndex" or "theI2" is greater than "UpperIndex" or "theI1" is greater than "theI2".
//! An exception is raised if "theI2-theI1+1" is different from the Length of "theV".
Standard_EXPORT void Set(const Standard_Integer theI1, const Standard_Integer theI2, const math_IntegerVector& theV);
//! slices the values of the IntegerVector between "theI1" and "theI2":
//! Example: [2, 1, 2, 3, 4, 5] becomes [2, 4, 3, 2, 1, 5] between 2 and 5.
//! An exception is raised if "theI1" is less than "LowerIndex" or "theI2" is greater than "UpperIndex".
Standard_EXPORT math_IntegerVector Slice(const Standard_Integer theI1, const Standard_Integer theI2) const;
//! returns the product of an IntegerVector by an integer value.
Standard_EXPORT void Multiply(const Standard_Integer theRight);
void operator *=(const Standard_Integer theRight)
{
Multiply(theRight);
}
//! returns the product of an IntegerVector by an integer value.
Standard_EXPORT math_IntegerVector Multiplied(const Standard_Integer theRight) const;
math_IntegerVector operator*(const Standard_Integer theRight) const
{
return Multiplied(theRight);
}
//! returns the product of a vector and a real value.
Standard_EXPORT math_IntegerVector TMultiplied(const Standard_Integer theRight) const;
friend inline math_IntegerVector operator* (const Standard_Integer theLeft, const math_IntegerVector& theRight)
{
return theRight.Multiplied(theLeft);
}
//! adds the IntegerVector "theRight" to an IntegerVector.
//! An exception is raised if the IntegerVectors have not the same length.
//! An exception is raised if the lengths are not equal.
Standard_EXPORT void Add(const math_IntegerVector& theRight);
void operator +=(const math_IntegerVector& theRight)
{
Add(theRight);
}
//! adds the IntegerVector "theRight" to an IntegerVector.
//! An exception is raised if the IntegerVectors have not the same length.
//! An exception is raised if the lengths are not equal.
Standard_EXPORT math_IntegerVector Added(const math_IntegerVector& theRight) const;
math_IntegerVector operator+(const math_IntegerVector& theRight) const
{
return Added(theRight);
}
//! sets an IntegerVector to the sum of the IntegerVector
//! "theLeft" and the IntegerVector "theRight".
//! An exception is raised if the lengths are different.
Standard_EXPORT void Add(const math_IntegerVector& theLeft, const math_IntegerVector& theRight);
//! sets an IntegerVector to the substraction of "theRight" from "theLeft".
//! An exception is raised if the IntegerVectors have not the same length.
Standard_EXPORT void Subtract(const math_IntegerVector& theLeft, const math_IntegerVector& theRight);
//! accesses (in read or write mode) the value of index theNum of an IntegerVector.
inline Standard_Integer& Value(const Standard_Integer theNum) const
{
Standard_RangeError_Raise_if(theNum < FirstIndex || theNum > LastIndex, " ");
return Array(theNum);
}
Standard_EXPORT Standard_Integer& operator()(const Standard_Integer theNum) const
{
return Value(theNum);
}
//! Initialises an IntegerVector by copying "theOther".
//! An exception is raised if the Lengths are different.
Standard_EXPORT math_IntegerVector& Initialized(const math_IntegerVector& theOther);
math_IntegerVector& operator=(const math_IntegerVector& theOther)
{
return Initialized(theOther);
}
//! returns the inner product of 2 IntegerVectors.
//! An exception is raised if the lengths are not equal.
Standard_EXPORT Standard_Integer Multiplied(const math_IntegerVector& theRight) const;
Standard_Integer operator*(const math_IntegerVector& theRight) const
{
return Multiplied(theRight);
}
//! returns the opposite of an IntegerVector.
Standard_EXPORT math_IntegerVector Opposite();
math_IntegerVector operator-()
{
return Opposite();
}
//! returns the subtraction of "theRight" from "me".
//! An exception is raised if the IntegerVectors have not the same length.
Standard_EXPORT void Subtract(const math_IntegerVector& theRight);
void operator-=(const math_IntegerVector& theRight)
{
Subtract(theRight);
}
//! returns the subtraction of "theRight" from "me".
//! An exception is raised if the IntegerVectors have not the same length.
Standard_EXPORT math_IntegerVector Subtracted(const math_IntegerVector& theRight) const;
math_IntegerVector operator-(const math_IntegerVector& theRight) const
{
return Subtracted(theRight);
}
//! returns the multiplication of an integer by an IntegerVector.
Standard_EXPORT void Multiply(const Standard_Integer theLeft,const math_IntegerVector& theRight);
//! Prints on the stream theO information on the current state of the object.
//! Is used to redefine the operator <<.
Standard_EXPORT void Dump(Standard_OStream& theO) const;
friend inline Standard_OStream& operator<<(Standard_OStream& theO, const math_IntegerVector& theVec)
{
theVec.Dump(theO);
return theO;
}
protected:
//! is used internally to set the Lower value of the IntegerVector.
void SetFirst(const Standard_Integer theFirst);
private:
Standard_Integer FirstIndex;
Standard_Integer LastIndex;
math_SingleTab<Standard_Integer> Array;
};
#endif

54
src/math/math_IntegerVector.lxx
View File

@ -1,54 +0,0 @@
// Copyright (c) 1997-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 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.
// lpa, le 29/10/91
#include <Standard_DimensionError.hxx>
inline Standard_OStream& operator<<(Standard_OStream& o,
const math_IntegerVector& vec)
{
vec.Dump(o);
return o;
}
inline math_IntegerVector operator* (const Standard_Integer Left,
const math_IntegerVector& Right)
{
return Right.Multiplied(Left);
}
inline Standard_Integer math_IntegerVector::Length() const
{ return LastIndex - FirstIndex +1;}
// length of a IntegerVector.
inline Standard_Integer math_IntegerVector::Lower() const
{ return FirstIndex;}
// value of the lower index of a IntegerVector.
inline Standard_Integer math_IntegerVector::Upper() const
{return LastIndex;}
// value of the Upper index of a IntegerVector.
inline Standard_Integer& math_IntegerVector::Value(const Standard_Integer Num) const {
Standard_RangeError_Raise_if(Num < FirstIndex || Num > LastIndex, " ");
return Array(Num);
}

4
src/math/math_Matrix.cdl
View File

@ -51,7 +51,7 @@ class Matrix from math
uses Vector from math, uses Vector from math,
DoubleTabOfReal from math, DoubleTab from math,
OStream from Standard OStream from Standard
raises DimensionError from Standard, RangeError from Standard, raises DimensionError from Standard, RangeError from Standard,
@ -562,7 +562,7 @@ LowerRowIndex: Integer;
UpperRowIndex: Integer; UpperRowIndex: Integer;
LowerColIndex: Integer; LowerColIndex: Integer;
UpperColIndex: Integer; UpperColIndex: Integer;
Array: DoubleTabOfReal; Array: DoubleTab;
friends friends
class Vector from math class Vector from math

4
src/math/math_Matrix.cxx
View File

@ -85,9 +85,7 @@ math_Matrix::math_Matrix (const Standard_Address Tab,
UpperRowIndex(UpperRow), UpperRowIndex(UpperRow),
LowerColIndex(LowerCol), LowerColIndex(LowerCol),
UpperColIndex(UpperCol), UpperColIndex(UpperCol),
Array(*((const Standard_Real *)Tab), Array(Tab, LowerRow, UpperRow, LowerCol, UpperCol)
LowerRow, UpperRow,
LowerCol, UpperCol)
{ {
Standard_RangeError_Raise_if((LowerRow > UpperRow) || Standard_RangeError_Raise_if((LowerRow > UpperRow) ||

61
src/math/math_SingleTab.cdl
View File

@ -1,61 +0,0 @@
-- Created on: 1992-02-04
-- Created by: Laurent PAINNOT
-- Copyright (c) 1992-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 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.
generic class SingleTab from math (Item as any)
uses Address from Standard
is
Create(LowerIndex, UpperIndex: Integer)
returns SingleTab;
Create(Tab : Item; LowerIndex, UpperIndex: Integer)
returns SingleTab;
Init(me : in out; InitValue: Item) is static;
Create(Other: SingleTab)
returns SingleTab;
Copy(me; Other : in out SingleTab)
---C++: inline
is static;
SetLower(me: in out; LowerIndex : Integer)
is static;
Value(me; Index: Integer)
---C++: alias operator()
---C++: return &
---C++: inline
returns Item
is static;
Free(me: in out)
---C++: alias ~
is static;
fields
Addr : Address;
Buf : Item[512];
isAllocated : Boolean;
First : Integer;
Last : Integer;
end;

87
src/math/math_SingleTab.gxx
View File

@ -1,87 +0,0 @@
// Copyright (c) 1997-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 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 <math_Memory.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Failure.hxx>
// macro to get size of C array
#define CARRAY_LENGTH(arr) (int)(sizeof(arr)/sizeof(arr[0]))
math_SingleTab::math_SingleTab(const Standard_Integer LowerIndex,
const Standard_Integer UpperIndex) :
Addr(Buf),
isAllocated(UpperIndex - LowerIndex + 1 > CARRAY_LENGTH(Buf)),
First(LowerIndex), Last(UpperIndex)
{
Item* TheAddr = !isAllocated? Buf :
(Item*) Standard::Allocate((Last-First+1) * sizeof(Item));
Addr = (Standard_Address) (TheAddr - First);
}
math_SingleTab::math_SingleTab(const Item& Tab,
const Standard_Integer LowerIndex,
const Standard_Integer UpperIndex) :
Addr((void*)(&Tab - LowerIndex)),
isAllocated(Standard_False),
First(LowerIndex), Last(UpperIndex)
{
}
void math_SingleTab::Init(const Item& InitValue)
{
for (Standard_Integer i=First; i<= Last; i++) {
((Item*)Addr)[i] = InitValue;
}
}
math_SingleTab::math_SingleTab(const math_SingleTab& Other) :
isAllocated(Other.Last - Other.First + 1 > CARRAY_LENGTH(Buf)),
First(Other.First),
Last(Other.Last)
{
Item* TheAddr = !isAllocated? Buf :
(Item*) Standard::Allocate((Last-First+1) * sizeof(Item));
Addr = (Standard_Address) (TheAddr - First);
Item* TheOtherAddr = (Item*) Other.Addr;
memmove((void*) TheAddr, (const void*) (TheOtherAddr + First),
(size_t)(Last - First + 1) * sizeof(Item));
}
void math_SingleTab::Free()
{
if(isAllocated) {
Standard_Address it = (Standard_Address)&((Item*)Addr)[First];
Standard::Free(it);
Addr = 0;
}
}
void math_SingleTab::SetLower(const Standard_Integer LowerIndex)
{
Item* TheAddr = (Item*) Addr;
Addr = (Standard_Address) (TheAddr + First - LowerIndex);
Last = Last - First + LowerIndex;
First = LowerIndex;
}

115
src/math/math_SingleTab.hxx Normal file
View File

@ -0,0 +1,115 @@
// Copyright (c) 1997-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 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.
#ifndef _math_SingleTab_HeaderFile
#define _math_SingleTab_HeaderFile
#include <math_Memory.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Failure.hxx>
static const Standard_Integer aLengthOfBuf = 512;
template<class T> class math_SingleTab
{
public:
DEFINE_STANDARD_ALLOC
math_SingleTab(const Standard_Integer LowerIndex, const Standard_Integer UpperIndex) :
Addr(Buf),
isAllocated(UpperIndex - LowerIndex + 1 > aLengthOfBuf),
First(LowerIndex), Last(UpperIndex)
{
T* TheAddr = !isAllocated? Buf :
(T*) Standard::Allocate((Last-First+1) * sizeof(T));
Addr = (Standard_Address) (TheAddr - First);
}
math_SingleTab(const Standard_Address Tab, const Standard_Integer LowerIndex, const Standard_Integer UpperIndex) :
Addr((void*)((const T*)Tab - LowerIndex)),
isAllocated(Standard_False),
First(LowerIndex), Last(UpperIndex)
{
}
void Init(const T InitValue)
{
for(Standard_Integer i = First; i<= Last; i++)
{
((T*)Addr)[i] = InitValue;
}
}
math_SingleTab(const math_SingleTab& Other) :
isAllocated(Other.Last - Other.First + 1 > aLengthOfBuf),
First(Other.First),
Last(Other.Last)
{
T* TheAddr = !isAllocated? Buf : (T*) Standard::Allocate((Last-First+1) * sizeof(T));
Addr = (Standard_Address) (TheAddr - First);
T* TheOtherAddr = (T*) Other.Addr;
memmove((void*) TheAddr, (const void*) (TheOtherAddr + First), (size_t)(Last - First + 1) * sizeof(T));
}
inline void Copy(math_SingleTab& Other) const
{
memmove((void*) (((T*)Other.Addr) + Other.First),
(const void*) (((T*)Addr) + First),
(size_t)(Last - First + 1) * sizeof(T));
}
void SetLower(const Standard_Integer LowerIndex)
{
T* TheAddr = (T*) Addr;
Addr = (Standard_Address) (TheAddr + First - LowerIndex);
Last = Last - First + LowerIndex;
First = LowerIndex;
}
inline T& Value(const Standard_Integer Index) const
{
return ((T*)Addr)[Index];
}
T& operator()(const Standard_Integer Index) const
{
return Value(Index);
}
void Free()
{
if(isAllocated)
{
Standard_Address it = (Standard_Address)&((T*)Addr)[First];
Standard::Free(it);
Addr = 0;
}
}
~math_SingleTab()
{
Free();
}
private:
Standard_Address Addr;
T Buf[aLengthOfBuf];
Standard_Boolean isAllocated;
Standard_Integer First;
Standard_Integer Last;
};
#endif

40
src/math/math_SingleTab.lxx
View File

@ -1,40 +0,0 @@
// Copyright (c) 1997-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 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_OutOfRange.hxx>
#include <math_Memory.hxx>
inline Item& math_SingleTab::Value(const Standard_Integer Index) const
{
return ((Item*)Addr)[Index];
}
inline void math_SingleTab::Copy(math_SingleTab& Other) const
{
memmove((void*) (((Item*)Other.Addr) + Other.First),
(const void*) (((Item*)Addr) + First),
(size_t)(Last - First + 1) * sizeof(Item));
}

433
src/math/math_Vector.cdl
View File

@ -1,433 +0,0 @@
-- Created on: 1991-05-06
-- Created by: Laurent PAINNOT
-- Copyright (c) 1991-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 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.
class Vector from math
---Purpose:
-- This class implements the real vector abstract data type.
-- Vectors can have an arbitrary range which must be defined at
-- the declaration and cannot be changed after this declaration.
-- math_Vector V1(-3, 5); // a vector with range [-3..5]
--
-- Vector are copied through assignement :
-- math_Vector V2( 1, 9);
-- ....
-- V2 = V1;
-- V1(1) = 2.0; // the vector V2 will not be modified.
--
-- The Exception RangeError is raised when trying to access outside
-- the range of a vector :
-- V1(11) = 0.0 // --> will raise RangeError;
--
-- The Exception DimensionError is raised when the dimensions of two
-- vectors are not compatible :
-- math_Vector V3(1, 2);
-- V3 = V1; // --> will raise DimensionError;
-- V1.Add(V3) // --> will raise DimensionError;
-- A Vector can be constructed with a a pointer to "c array".
-- It allows to carry the bounds inside the Vector.
-- Exemple :
-- Standard_Real tab1[10];
--
-- math_Vector A (tab1[0], 1, 10);
-- Vector values may be initialized and
-- obtained using indexes which must lie within the range
-- definition of the vector.
-- Vector objects follow "value semantics", that is, they
-- cannot be shared and are copied through assignment.
-- Note: the overview of the Vectors and Matrices
-- component illustrates these properties on vectors.
uses Matrix from math,
SingleTabOfReal from math,
OStream from Standard
raises DimensionError from Standard,
DivideByZero from Standard,
RangeError from Standard,
NullValue from Standard
is
Create(Lower, Upper: Integer)
---Purpose: Contructs a non-initialized vector in the range [Lower..Upper]
-- Lower and Upper are the indexes of the lower and upper
-- bounds of the constructed vector.
returns Vector;
Create(Lower, Upper: Integer; InitialValue : Real)
---Purpose: Contructs a vector in the range [Lower..Upper]
-- whose values are all initialized with the value InitialValue..
returns Vector;
Create(Tab : Address; Lower, Upper: Integer)
---Purpose: Constructs a vector in the range [Lower..Upper]
-- with the "c array" Tab.
returns Vector;
Init(me : in out; InitialValue: Real)
---Purpose: Initialize all the elements of a vector with InitialValue.
is static;
Create(Other: Vector)
---Purpose: Constructs a copy for initialization.
-- An exception is raised if the lengths of the vectors are
-- different.
returns Vector
raises DimensionError;
--JR/Hpis private;
SetLower(me: in out; Lower: Integer)
---Purpose: Is used internally to set the Lower value of the vector.
is static protected;
Length(me)
---Purpose: Returns the length of a vector
---C++: inline
returns Integer
is static;
Lower(me)
---Purpose: Returns the value of the Lower index of a vector.
---C++: inline
returns Integer
is static;
Upper(me)
---Purpose: Returns the value of the Upper index of a vector.
---C++: inline
returns Integer
is static;
Norm(me)
---Purpose: Returns the value or the square of the norm of this vector.
returns Real
is static;
Norm2 (me)
---Purpose: Returns the value of the square of the norm of a vector.
returns Real
is static;
Max(me)
---Purpose: Returns the value of the Index of the maximum element of a vector.
returns Integer
is static;
Min(me)
---Purpose: Returns the value of the Index of the minimum element of a vector.
returns Integer
is static;
Normalize(me: in out)
---Purpose: Normalizes this vector (the norm of the result
-- is equal to 1.0) and assigns the result to this vector
-- Exceptions
-- Standard_NullValue if this vector is null (i.e. if its norm is
-- less than or equal to Standard_Real::RealEpsilon().
raises NullValue
is static;
Normalized(me)
---Purpose: Normalizes this vector (the norm of the result
-- is equal to 1.0) and creates a new vector
-- Exceptions
-- Standard_NullValue if this vector is null (i.e. if its norm is
-- less than or equal to Standard_Real::RealEpsilon().
returns Vector
raises NullValue
is static;
Invert(me: in out)
---Purpose: Inverts this vector and assigns the result to this vector.
--If the values of this vector were (1.,
-- 2., 3., 4.), the result values are (4., 3., 2., 1.).
-- Example: [1, 2, 3, 4] becomes [4, 3, 2, 1].
is static;
Inverse(me)
---Purpose: Inverts this vector and creates a new vector.
--If the values of this vector were (1.,
-- 2., 3., 4.), the result values are (4., 3., 2., 1.).
-- Example: if <me> = [1, 2, 3, 4], the method returns [4, 3, 2, 1].
returns Vector
is static;
Set(me: in out; I1, I2: Integer; V: Vector)
---Purpose: sets a vector from <I1> to <I2> to the vector <V>;
-- An exception is raised if I1<LowerIndex or I2>UpperIndex or I1>I2.
-- An exception is raised if I2-I1+1 is different from the Length of V.
raises RangeError
is static;
Slice(me; I1, I2: Integer)
---Purpose:Creates a new vector by inverting the values of this vector
-- between indexes I1 and I2.
-- If the values of this vector were (1., 2., 3., 4.,
-- 5., 6.), by slicing it between indexes 2 and 5 the
-- values of the resulting vector are (1., 5., 4., 3., 2., 6.)
---Example: [2, 1, 2, 3, 4, 5] becomes [2, 4, 3, 2, 1, 5] between 2 and 5.
-- An exception is raised if I1<LowerIndex or I2>UpperIndex.
returns Vector
raises RangeError
is static;
Multiply (me: in out; Right: Real)
---Purpose: returns the product of a vector and a real value.
---C++: alias operator *=
is static;
Multiplied (me; Right: Real)
---Purpose: returns the product of a vector and a real value.
---C++: alias operator*
returns Vector
is static;
TMultiplied (me; Right: Real)
---Purpose: returns the product of a vector and a real value.
---C++: alias "friend math_Vector operator *(const Standard_Real Left,const math_Vector& Right);"
returns Vector
is static;
Divide (me: in out; Right: Real)
---Purpose: divides a vector by the value <Right>.
-- An exception is raised if <Right> = 0.
---C++: alias operator /=
raises DivideByZero from Standard
is static;
Divided (me; Right: Real)
---Purpose: divides a vector by the value <Right>.
-- An exception is raised if <Right> = 0.
---C++: alias operator/
returns Vector
raises DivideByZero from Standard
is static;
Add (me: in out; Right: Vector)
---Purpose: adds the vector <Right> to a vector.
-- An exception is raised if the vectors have not the same length.
-- Warning
-- In order to avoid time-consuming copying of vectors, it
-- is preferable to use operator += or the function Add whenever possible.
---C++: alias operator +=
raises DimensionError
is static;
Added (me; Right: Vector)
---Purpose: adds the vector <Right> to a vector.
-- An exception is raised if the vectors have not the same length.
-- An exception is raised if the lengths are not equal.
---C++:alias operator+
returns Vector
raises DimensionError
is static;
Multiply (me: in out; Left: Vector; Right: Matrix)
---Purpose: sets a vector to the product of the vector <Left>
-- with the matrix <Right>.
raises DimensionError
is static;
Multiply (me: in out; Left: Matrix; Right: Vector)
---Purpose:sets a vector to the product of the matrix <Left>
-- with the vector <Right>.
raises DimensionError
is static;
TMultiply (me: in out; TLeft: Matrix; Right: Vector)
---Purpose: sets a vector to the product of the transpose
-- of the matrix <TLeft> by the vector <Right>.
raises DimensionError
is static;
TMultiply (me: in out; Left: Vector; TRight: Matrix)
---Purpose: sets a vector to the product of the vector
-- <Left> by the transpose of the matrix <TRight>.
raises DimensionError
is static;
Add (me: in out; Left, Right: Vector)
---Purpose: sets a vector to the sum of the vector <Left>
-- and the vector <Right>.
-- An exception is raised if the lengths are different.
raises DimensionError
is static;
Subtract(me: in out; Left, Right: Vector)
---Purpose: sets a vector to the Subtraction of the
-- vector <Right> from the vector <Left>.
-- An exception is raised if the vectors have not the same length.
-- Warning
-- In order to avoid time-consuming copying of vectors, it
-- is preferable to use operator -= or the function
-- Subtract whenever possible.
raises DimensionError
is static;
Value(me; Num: Integer)
---Purpose: accesses (in read or write mode) the value of index Num of
-- a vector.
---C++: alias operator()
---C++: return &
---C++: inline
returns Real
raises RangeError from Standard
is static;
Initialized(me: in out; Other: Vector)
---Purpose: Initialises a vector by copying <Other>.
-- An exception is raised if the Lengths are differents.
---C++: alias operator=
---C++: return &
returns Vector
raises DimensionError
is static;
Multiplied(me; Right: Vector)
---Purpose: returns the inner product of 2 vectors.
-- An exception is raised if the lengths are not equal.
---C++: alias operator*
returns Real
raises DimensionError
is static;
Multiplied(me; Right: Matrix)
---Purpose: returns the product of a vector by a matrix.
---C++: alias operator*
returns Vector
raises DimensionError
is static;
Opposite(me : in out)
---Purpose: returns the opposite of a vector.
---C++: alias operator-
returns Vector
is static;
Subtract(me: in out; Right: Vector)
---Purpose: returns the subtraction of <Right> from <me>.
-- An exception is raised if the vectors have not the same length.
---C++: alias operator-=
raises DimensionError
is static;
Subtracted(me; Right: Vector)
---Purpose: returns the subtraction of <Right> from <me>.
-- An exception is raised if the vectors have not the same length.
---C++: alias operator-
returns Vector
raises DimensionError
is static;
Multiply(me: in out; Left: Real; Right: Vector)
---Purpose: returns the multiplication of a real by a vector.
-- <me> = <Left> * <Right>
raises DimensionError
is static;
Dump(me; o: in out OStream)
---Purpose: Prints information on the current state of the object.
-- Is used to redefine the operator <<.
is static;
fields
LowerIndex: Integer;
UpperIndex: Integer;
Array: SingleTabOfReal;
friends
class Matrix from math
end Vector;

565
src/math/math_Vector.cxx
View File

@ -14,7 +14,7 @@
#include <stdio.h> #include <stdio.h>
#include <math_Vector.ixx> #include <math_Vector.hxx>
#include <math_Matrix.hxx> #include <math_Matrix.hxx>
#include <Standard_DimensionError.hxx> #include <Standard_DimensionError.hxx>
@ -22,84 +22,85 @@
#include <Standard_RangeError.hxx> #include <Standard_RangeError.hxx>
#include <Standard_NullValue.hxx> #include <Standard_NullValue.hxx>
math_Vector::math_Vector(const Standard_Integer theLower, const Standard_Integer theUpper) :
math_Vector::math_Vector(const Standard_Integer Lower, LowerIndex(theLower),
const Standard_Integer Upper): UpperIndex(theUpper),
Array(theLower,theUpper)
LowerIndex(Lower),
UpperIndex(Upper),
Array(Lower,Upper) {
Standard_RangeError_Raise_if(Lower > Upper, "");
}
math_Vector::math_Vector(const Standard_Integer Lower,
const Standard_Integer Upper,
const Standard_Real InitialValue):
LowerIndex(Lower),
UpperIndex(Upper),
Array(Lower,Upper)
{ {
Standard_RangeError_Raise_if(Lower > Upper, ""); Standard_RangeError_Raise_if(theLower > theUpper, "");
Array.Init(InitialValue);
} }
math_Vector::math_Vector(const Standard_Address Tab, math_Vector::math_Vector(const Standard_Integer theLower,
const Standard_Integer Lower, const Standard_Integer theUpper,
const Standard_Integer Upper) : const Standard_Real theInitialValue):
LowerIndex(theLower),
LowerIndex(Lower), UpperIndex(theUpper),
UpperIndex(Upper), Array(theLower,theUpper)
Array(*((const Standard_Real *)Tab), Lower,Upper)
{ {
Standard_RangeError_Raise_if((Lower > Upper) , ""); Standard_RangeError_Raise_if(theLower > theUpper, "");
Array.Init(theInitialValue);
} }
void math_Vector::Init(const Standard_Real InitialValue) { math_Vector::math_Vector(const Standard_Address theTab,
Array.Init(InitialValue); const Standard_Integer theLower,
const Standard_Integer theUpper) :
LowerIndex(theLower),
UpperIndex(theUpper),
Array(theTab, theLower,theUpper)
{
Standard_RangeError_Raise_if((theLower > theUpper) , "");
} }
math_Vector::math_Vector(const math_Vector& Other): void math_Vector::Init(const Standard_Real theInitialValue)
{
LowerIndex(Other.LowerIndex), Array.Init(theInitialValue);
UpperIndex(Other.UpperIndex),
Array(Other.Array) {}
void math_Vector::SetLower(const Standard_Integer Lower) {
Array.SetLower(Lower);
UpperIndex = UpperIndex - LowerIndex + Lower;
LowerIndex = Lower;
} }
Standard_Real math_Vector::Norm() const { math_Vector::math_Vector(const math_Vector& theOther) :
LowerIndex(theOther.LowerIndex),
UpperIndex(theOther.UpperIndex),
Array(theOther.Array)
{
}
void math_Vector::SetLower(const Standard_Integer theLower)
{
Array.SetLower(theLower);
UpperIndex = UpperIndex - LowerIndex + theLower;
LowerIndex = theLower;
}
Standard_Real math_Vector::Norm() const
{
Standard_Real Result = 0; Standard_Real Result = 0;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
{
Result = Result + Array(Index) * Array(Index); Result = Result + Array(Index) * Array(Index);
} }
return Sqrt(Result); return Sqrt(Result);
} }
Standard_Real math_Vector::Norm2() const { Standard_Real math_Vector::Norm2() const
{
Standard_Real Result = 0; Standard_Real Result = 0;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
{
Result = Result + Array(Index) * Array(Index); Result = Result + Array(Index) * Array(Index);
} }
return Result; return Result;
} }
Standard_Integer math_Vector::Max() const { Standard_Integer math_Vector::Max() const
{
Standard_Integer I=0; Standard_Integer I=0;
Standard_Real X = RealFirst(); Standard_Real X = RealFirst();
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
if(Array(Index) > X) { {
if(Array(Index) > X)
{
X = Array(Index); X = Array(Index);
I = Index; I = Index;
} }
@ -107,13 +108,15 @@ Standard_Integer math_Vector::Max() const {
return I; return I;
} }
Standard_Integer math_Vector::Min() const { Standard_Integer math_Vector::Min() const
{
Standard_Integer I=0; Standard_Integer I=0;
Standard_Real X = RealLast(); Standard_Real X = RealLast();
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
if(Array(Index) < X) { {
if(Array(Index) < X)
{
X = Array(Index); X = Array(Index);
I = Index; I = Index;
} }
@ -121,45 +124,45 @@ Standard_Integer math_Vector::Min() const {
return I; return I;
} }
void math_Vector::Set(const Standard_Integer I1, void math_Vector::Set(const Standard_Integer theI1,
const Standard_Integer I2, const Standard_Integer theI2,
const math_Vector &V) { const math_Vector &theV)
{
Standard_RangeError_Raise_if((theI1 < LowerIndex) || (theI2 > UpperIndex) ||
(theI1 > theI2) || (theI2 - theI1 + 1 != theV.Length()), "");
Standard_RangeError_Raise_if((I1 < LowerIndex) || Standard_Integer I = theV.Lower();
(I2 > UpperIndex) || for(Standard_Integer Index = theI1; Index <= theI2; Index++)
(I1 > I2) || {
(I2 - I1 + 1 != V.Length()), ""); Array(Index) = theV.Array(I);
Standard_Integer I = V.Lower();
for(Standard_Integer Index = I1; Index <= I2; Index++) {
Array(Index) = V.Array(I);
I++; I++;
} }
} }
void math_Vector::Normalize() { void math_Vector::Normalize()
{
Standard_Real Result = Norm(); Standard_Real Result = Norm();
Standard_NullValue_Raise_if((Result <= RealEpsilon()), ""); Standard_NullValue_Raise_if((Result <= RealEpsilon()), "");
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
{
Array(Index) = Array(Index) / Result; Array(Index) = Array(Index) / Result;
} }
} }
math_Vector math_Vector::Normalized() const { math_Vector math_Vector::Normalized() const
{
math_Vector Result = *this; math_Vector Result = *this;
Result.Normalize(); Result.Normalize();
return Result; return Result;
} }
void math_Vector::Invert() { void math_Vector::Invert()
{
Standard_Integer J; Standard_Integer J;
Standard_Real Temp; Standard_Real Temp;
for(Standard_Integer Index = LowerIndex; for(Standard_Integer Index = LowerIndex; Index <= (LowerIndex + Length()) >> 1 ; Index++)
// Index <= LowerIndex + (Length()) >> 1 ; Index++) { {
Index <= (LowerIndex + Length()) >> 1 ; Index++) {
J = UpperIndex + LowerIndex - Index; J = UpperIndex + LowerIndex - Index;
Temp = Array(Index); Temp = Array(Index);
Array(Index) = Array(J); Array(Index) = Array(J);
@ -167,316 +170,310 @@ void math_Vector::Invert() {
} }
} }
math_Vector math_Vector::Inverse() const { math_Vector math_Vector::Inverse() const
{
math_Vector Result = *this; math_Vector Result = *this;
Result.Invert(); Result.Invert();
return Result; return Result;
} }
math_Vector math_Vector::Multiplied(const Standard_Real Right) const{ math_Vector math_Vector::Multiplied(const Standard_Real theRight) const
{
math_Vector Result (LowerIndex, UpperIndex); math_Vector Result (LowerIndex, UpperIndex);
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
Result.Array(Index) = Array(Index) * Right; {
Result.Array(Index) = Array(Index) * theRight;
} }
return Result; return Result;
} }
math_Vector math_Vector::TMultiplied(const Standard_Real Right) const{ math_Vector math_Vector::TMultiplied(const Standard_Real theRight) const
{
math_Vector Result (LowerIndex, UpperIndex); math_Vector Result (LowerIndex, UpperIndex);
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
Result.Array(Index) = Array(Index) * Right; {
Result.Array(Index) = Array(Index) * theRight;
} }
return Result; return Result;
} }
void math_Vector::Multiply(const Standard_Real theRight)
void math_Vector::Multiply(const Standard_Real Right) { {
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { {
Array(Index) = Array(Index) * Right; Array(Index) = Array(Index) * theRight;
} }
} }
void math_Vector::Divide(const Standard_Real theRight)
{
Standard_DivideByZero_Raise_if(Abs(theRight) <= RealEpsilon(), "");
void math_Vector::Divide(const Standard_Real Right) { for(Standard_Integer Index =LowerIndex; Index <=UpperIndex; Index++)
{
Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), ""); Array(Index) = Array(Index) / theRight;
for(Standard_Integer Index =LowerIndex; Index <=UpperIndex; Index++) {
Array(Index) = Array(Index) / Right;
} }
} }
math_Vector math_Vector::Divided (const Standard_Real theRight) const
math_Vector math_Vector::Divided (const Standard_Real Right) const { {
Standard_DivideByZero_Raise_if(Abs(theRight) <= RealEpsilon(), "");
Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), ""); math_Vector temp = Multiplied(1./theRight);
math_Vector temp = Multiplied(1./Right);
return temp; return temp;
} }
void math_Vector::Add(const math_Vector& theRight)
void math_Vector::Add(const math_Vector& Right) {
Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
Standard_Integer I = Right.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
Array(Index) = Array(Index) + Right.Array(I);
I++;
}
}
math_Vector math_Vector::Added(const math_Vector& Right) const{
Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
math_Vector Result(LowerIndex, UpperIndex);
Standard_Integer I = Right.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
Result.Array(Index) = Array(Index) + Right.Array(I);
I++;
}
return Result;
}
void math_Vector::Subtract(const math_Vector& Right) {
Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
Standard_Integer I = Right.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
Array(Index) = Array(Index) - Right.Array(I);
I++;
}
}
math_Vector math_Vector::Subtracted (const math_Vector& Right) const {
Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
math_Vector Result(LowerIndex, UpperIndex);
Standard_Integer I = Right.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
Result.Array(Index) = Array(Index) - Right.Array(I);
I++;
}
return Result;
}
math_Vector math_Vector::Slice(const Standard_Integer I1,
const Standard_Integer I2) const
{ {
Standard_DimensionError_Raise_if(Length() != theRight.Length(), "");
Standard_RangeError_Raise_if((I1 < LowerIndex) ||
(I1 > UpperIndex) ||
(I2 < LowerIndex) ||
(I2 > UpperIndex) , "");
if(I2 >= I1) { Standard_Integer I = theRight.LowerIndex;
math_Vector Result(I1, I2); for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
for(Standard_Integer Index = I1; Index <= I2; Index++) { {
Result.Array(Index) = Array(Index); Array(Index) = Array(Index) + theRight.Array(I);
} I++;
return Result;
} }
else { }
math_Vector Result(I2, I1);
for(Standard_Integer Index = I1; Index >= I2; Index--) { math_Vector math_Vector::Added(const math_Vector& theRight) const
{
Standard_DimensionError_Raise_if(Length() != theRight.Length(), "");
math_Vector Result(LowerIndex, UpperIndex);
Standard_Integer I = theRight.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
{
Result.Array(Index) = Array(Index) + theRight.Array(I);
I++;
}
return Result;
}
void math_Vector::Subtract(const math_Vector& theRight)
{
Standard_DimensionError_Raise_if(Length() != theRight.Length(), "");
Standard_Integer I = theRight.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
{
Array(Index) = Array(Index) - theRight.Array(I);
I++;
}
}
math_Vector math_Vector::Subtracted (const math_Vector& theRight) const
{
Standard_DimensionError_Raise_if(Length() != theRight.Length(), "");
math_Vector Result(LowerIndex, UpperIndex);
Standard_Integer I = theRight.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
{
Result.Array(Index) = Array(Index) - theRight.Array(I);
I++;
}
return Result;
}
math_Vector math_Vector::Slice(const Standard_Integer theI1, const Standard_Integer theI2) const
{
Standard_RangeError_Raise_if((theI1 < LowerIndex) || (theI1 > UpperIndex) || (theI2 < LowerIndex) || (theI2 > UpperIndex) , "");
if(theI2 >= theI1)
{
math_Vector Result(theI1, theI2);
for(Standard_Integer Index = theI1; Index <= theI2; Index++)
{
Result.Array(Index) = Array(Index); Result.Array(Index) = Array(Index);
} }
return Result; return Result;
} }
else
{
math_Vector Result(theI2, theI1);
for(Standard_Integer Index = theI1; Index >= theI2; Index--)
{
Result.Array(Index) = Array(Index);
}
return Result;
}
} }
void math_Vector::Add (const math_Vector& theLeft, const math_Vector& theRight)
{
Standard_DimensionError_Raise_if((Length() != theRight.Length()) || (theRight.Length() != theLeft.Length()), "");
void math_Vector::Add (const math_Vector& Left, const math_Vector& Right) { Standard_Integer I = theLeft.LowerIndex;
Standard_Integer J = theRight.LowerIndex;
Standard_DimensionError_Raise_if((Length() != Right.Length()) || for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
(Right.Length() != Left.Length()), ""); {
Array(Index) = theLeft.Array(I) + theRight.Array(J);
Standard_Integer I = Left.LowerIndex;
Standard_Integer J = Right.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
Array(Index) = Left.Array(I) + Right.Array(J);
I++; I++;
J++; J++;
} }
} }
void math_Vector::Subtract (const math_Vector& Left, void math_Vector::Subtract (const math_Vector& theLeft, const math_Vector& theRight)
const math_Vector& Right) { {
Standard_DimensionError_Raise_if((Length() != theRight.Length()) || (theRight.Length() != theLeft.Length()), "");
Standard_DimensionError_Raise_if((Length() != Right.Length()) || Standard_Integer I = theLeft.LowerIndex;
(Right.Length() != Left.Length()), ""); Standard_Integer J = theRight.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
Standard_Integer I = Left.LowerIndex; {
Standard_Integer J = Right.LowerIndex; Array(Index) = theLeft.Array(I) - theRight.Array(J);
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
Array(Index) = Left.Array(I) - Right.Array(J);
I++; I++;
J++; J++;
} }
} }
void math_Vector::Multiply(const math_Matrix& Left, void math_Vector::Multiply(const math_Matrix& theLeft, const math_Vector& theRight)
const math_Vector& Right) { {
Standard_DimensionError_Raise_if((Length() != theLeft.RowNumber()) ||
Standard_DimensionError_Raise_if((Length() != Left.RowNumber()) || (theLeft.ColNumber() != theRight.Length()), "");
(Left.ColNumber() != Right.Length()),
"");
Standard_Integer Index = LowerIndex; Standard_Integer Index = LowerIndex;
for(Standard_Integer I = Left.LowerRowIndex; I <= Left.UpperRowIndex; I++) { for(Standard_Integer I = theLeft.LowerRowIndex; I <= theLeft.UpperRowIndex; I++)
{
Array(Index) = 0.0; Array(Index) = 0.0;
Standard_Integer K = Right.LowerIndex; Standard_Integer K = theRight.LowerIndex;
for(Standard_Integer J = Left.LowerColIndex; J <= Left.UpperColIndex; J++) { for(Standard_Integer J = theLeft.LowerColIndex; J <= theLeft.UpperColIndex; J++)
Array(Index) = Array(Index) + Left.Array(I, J) * Right.Array(K); {
Array(Index) = Array(Index) + theLeft.Array(I, J) * theRight.Array(K);
K++; K++;
} }
Index++; Index++;
} }
} }
void math_Vector::Multiply(const math_Vector& Left, void math_Vector::Multiply(const math_Vector& theLeft, const math_Matrix& theRight)
const math_Matrix& Right) { {
Standard_DimensionError_Raise_if((Length() != theRight.ColNumber()) ||
Standard_DimensionError_Raise_if((Length() != Right.ColNumber()) || (theLeft.Length() != theRight.RowNumber()), "");
(Left.Length() != Right.RowNumber()),
"");
Standard_Integer Index = LowerIndex; Standard_Integer Index = LowerIndex;
for(Standard_Integer J = Right.LowerColIndex; J <= Right.UpperColIndex; J++) { for(Standard_Integer J = theRight.LowerColIndex; J <= theRight.UpperColIndex; J++)
{
Array(Index) = 0.0; Array(Index) = 0.0;
Standard_Integer K = Left.LowerIndex; Standard_Integer K = theLeft.LowerIndex;
for(Standard_Integer I = Right.LowerRowIndex; I <= Right.UpperRowIndex; I++) { for(Standard_Integer I = theRight.LowerRowIndex; I <= theRight.UpperRowIndex; I++)
Array(Index) = Array(Index) + Left.Array(K) * Right.Array(I, J); {
Array(Index) = Array(Index) + theLeft.Array(K) * theRight.Array(I, J);
K++; K++;
} }
Index++; Index++;
} }
} }
void math_Vector::TMultiply(const math_Matrix& TLeft, void math_Vector::TMultiply(const math_Matrix& theTLeft, const math_Vector& theRight)
const math_Vector& Right) { {
Standard_DimensionError_Raise_if((Length() != theTLeft.ColNumber()) ||
Standard_DimensionError_Raise_if((Length() != TLeft.ColNumber()) || (theTLeft.RowNumber() != theRight.Length()), "");
(TLeft.RowNumber() != Right.Length()),
"");
Standard_Integer Index = LowerIndex; Standard_Integer Index = LowerIndex;
for(Standard_Integer I = TLeft.LowerColIndex; I <= TLeft.UpperColIndex; I++) { for(Standard_Integer I = theTLeft.LowerColIndex; I <= theTLeft.UpperColIndex; I++)
{
Array(Index) = 0.0; Array(Index) = 0.0;
Standard_Integer K = Right.LowerIndex; Standard_Integer K = theRight.LowerIndex;
for(Standard_Integer J = TLeft.LowerRowIndex; J <= TLeft.UpperRowIndex; J++) { for(Standard_Integer J = theTLeft.LowerRowIndex; J <= theTLeft.UpperRowIndex; J++)
Array(Index) = Array(Index) + TLeft.Array(J, I) * Right.Array(K); {
Array(Index) = Array(Index) + theTLeft.Array(J, I) * theRight.Array(K);
K++; K++;
} }
Index++; Index++;
} }
} }
void math_Vector::TMultiply(const math_Vector& Left, void math_Vector::TMultiply(const math_Vector& theLeft, const math_Matrix& theTRight)
const math_Matrix& TRight) { {
Standard_DimensionError_Raise_if((Length() != theTRight.RowNumber()) ||
Standard_DimensionError_Raise_if((Length() != TRight.RowNumber()) || (theLeft.Length() != theTRight.ColNumber()), "");
(Left.Length() != TRight.ColNumber()),
"");
Standard_Integer Index = LowerIndex; Standard_Integer Index = LowerIndex;
for(Standard_Integer J = TRight.LowerRowIndex; J <= TRight.UpperRowIndex; J++) { for(Standard_Integer J = theTRight.LowerRowIndex; J <= theTRight.UpperRowIndex; J++)
{
Array(Index) = 0.0; Array(Index) = 0.0;
Standard_Integer K = Left.LowerIndex; Standard_Integer K = theLeft.LowerIndex;
for(Standard_Integer I = TRight.LowerColIndex; for(Standard_Integer I = theTRight.LowerColIndex;
I <= TRight.UpperColIndex; I++) { I <= theTRight.UpperColIndex; I++)
Array(Index) = Array(Index) + Left.Array(K) * TRight.Array(J, I); {
K++; Array(Index) = Array(Index) + theLeft.Array(K) * theTRight.Array(J, I);
K++;
} }
Index++; Index++;
} }
} }
Standard_Real math_Vector::Multiplied(const math_Vector& theRight) const
{
Standard_Real math_Vector::Multiplied(const math_Vector& Right) const{
Standard_Real Result = 0; Standard_Real Result = 0;
Standard_DimensionError_Raise_if(Length() != Right.Length(), ""); Standard_DimensionError_Raise_if(Length() != theRight.Length(), "");
Standard_Integer I = Right.LowerIndex; Standard_Integer I = theRight.LowerIndex;
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
Result = Result + Array(Index) * Right.Array(I); {
Result = Result + Array(Index) * theRight.Array(I);
I++; I++;
} }
return Result; return Result;
} }
math_Vector math_Vector::Opposite() { math_Vector math_Vector::Opposite()
{
math_Vector Result(LowerIndex, UpperIndex); math_Vector Result(LowerIndex, UpperIndex);
for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) { for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
{
Result.Array(Index) = - Array(Index); Result.Array(Index) = - Array(Index);
} }
return Result; return Result;
} }
math_Vector math_Vector::Multiplied(const math_Matrix& Right)const { math_Vector math_Vector::Multiplied(const math_Matrix& theRight)const
Standard_DimensionError_Raise_if(Length() != Right.RowNumber(), ""); {
Standard_DimensionError_Raise_if(Length() != theRight.RowNumber(), "");
math_Vector Result(Right.LowerColIndex, Right.UpperColIndex); math_Vector Result(theRight.LowerColIndex, theRight.UpperColIndex);
for(Standard_Integer J2 = Right.LowerColIndex; for(Standard_Integer J2 = theRight.LowerColIndex; J2 <= theRight.UpperColIndex; J2++)
J2 <= Right.UpperColIndex; J2++) { {
Array(J2) = 0.0; Array(J2) = 0.0;
Standard_Integer I2 = Right.LowerRowIndex; Standard_Integer theI2 = theRight.LowerRowIndex;
for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++) { for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++)
Result.Array(J2) = Result.Array(J2) + Array(I) * {
Right.Array(I2, J2); Result.Array(J2) = Result.Array(J2) + Array(I) * theRight.Array(theI2, J2);
I2++; theI2++;
} }
} }
return Result; return Result;
} }
void math_Vector::Multiply(const Standard_Real theLeft, const math_Vector& theRight)
void math_Vector::Multiply(const Standard_Real Left,
const math_Vector& Right)
{ {
Standard_DimensionError_Raise_if((Length() != Right.Length()), Standard_DimensionError_Raise_if((Length() != theRight.Length()), "");
""); for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++)
for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++) { {
Array(I) = Left * Right.Array(I); Array(I) = theLeft * theRight.Array(I);
} }
} }
math_Vector& math_Vector::Initialized(const math_Vector& theOther)
{
Standard_DimensionError_Raise_if(Length() != theOther.Length(), "");
math_Vector& math_Vector::Initialized(const math_Vector& Other) { (theOther.Array).Copy(Array);
Standard_DimensionError_Raise_if(Length() != Other.Length(), "");
(Other.Array).Copy(Array);
return *this; return *this;
} }
void math_Vector::Dump(Standard_OStream& theO) const
void math_Vector::Dump(Standard_OStream& o) const
{ {
o << "math_Vector of Length = " << Length() << "\n"; theO << "math_Vector of Length = " << Length() << "\n";
for(Standard_Integer Index = LowerIndex; for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++)
Index <= UpperIndex; Index++) { {
o << "math_Vector(" << Index << ") = " << Array(Index) << "\n"; theO << "math_Vector(" << Index << ") = " << Array(Index) << "\n";
} }
} }

326
src/math/math_Vector.hxx Normal file
View File

@ -0,0 +1,326 @@
// Copyright (c) 1997-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 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.
#ifndef _math_Vector_HeaderFile
#define _math_Vector_HeaderFile
#include <math_SingleTab.hxx>
class Standard_DimensionError;
class Standard_DivideByZero;
class Standard_RangeError;
class Standard_NullValue;
class math_Matrix;
//! This class implements the real vector abstract data type.
//! Vectors can have an arbitrary range which must be defined at
//! the declaration and cannot be changed after this declaration.
//! @code
//! math_Vector V1(-3, 5); // a vector with range [-3..5]
//! @endcode
//!
//! Vector are copied through assignement :
//! @code
//! math_Vector V2( 1, 9);
//! ....
//! V2 = V1;
//! V1(1) = 2.0; // the vector V2 will not be modified.
//! @endcode
//!
//! The Exception RangeError is raised when trying to access outside
//! the range of a vector :
//! @code
//! V1(11) = 0.0 // --> will raise RangeError;
//! @endcode
//!
//! The Exception DimensionError is raised when the dimensions of two
//! vectors are not compatible :
//! @code
//! math_Vector V3(1, 2);
//! V3 = V1; // --> will raise DimensionError;
//! V1.Add(V3) // --> will raise DimensionError;
//! @endcode
class math_Vector
{
public:
DEFINE_STANDARD_ALLOC
//! Contructs a non-initialized vector in the range [theLower..theUpper]
//! "theLower" and "theUpper" are the indexes of the lower and upper bounds of the constructed vector.
Standard_EXPORT math_Vector(const Standard_Integer theLower, const Standard_Integer theUpper);
//! Contructs a vector in the range [theLower..theUpper]
//! whose values are all initialized with the value "theInitialValue"
Standard_EXPORT math_Vector(const Standard_Integer theLower, const Standard_Integer theUpper, const Standard_Real theInitialValue);
//! Constructs a vector in the range [theLower..theUpper]
//! with the "c array" theTab.
Standard_EXPORT math_Vector(const Standard_Address theTab, const Standard_Integer theLower, const Standard_Integer theUpper);
//! Initialize all the elements of a vector with "theInitialValue".
Standard_EXPORT void Init(const Standard_Real theInitialValue);
//! Constructs a copy for initialization.
//! An exception is raised if the lengths of the vectors are different.
Standard_EXPORT math_Vector(const math_Vector& theOther);
//! Returns the length of a vector
inline Standard_Integer Length() const
{
return UpperIndex - LowerIndex +1;
}
//! Returns the value of the theLower index of a vector.
inline Standard_Integer Lower() const
{
return LowerIndex;
}
//! Returns the value of the theUpper index of a vector.
inline Standard_Integer Upper() const
{
return UpperIndex;
}
//! Returns the value or the square of the norm of this vector.
Standard_EXPORT Standard_Real Norm() const;
//! Returns the value of the square of the norm of a vector.
Standard_EXPORT Standard_Real Norm2() const;
//! Returns the value of the "Index" of the maximum element of a vector.
Standard_EXPORT Standard_Integer Max() const;
//! Returns the value of the "Index" of the minimum element of a vector.
Standard_EXPORT Standard_Integer Min() const;
//! Normalizes this vector (the norm of the result
//! is equal to 1.0) and assigns the result to this vector
//! Exceptions
//! Standard_NullValue if this vector is null (i.e. if its norm is
//! less than or equal to Standard_Real::RealEpsilon().
Standard_EXPORT void Normalize();
//! Normalizes this vector (the norm of the result
//! is equal to 1.0) and creates a new vector
//! Exceptions
//! Standard_NullValue if this vector is null (i.e. if its norm is
//! less than or equal to Standard_Real::RealEpsilon().
Standard_EXPORT math_Vector Normalized() const;
//! Inverts this vector and assigns the result to this vector.
Standard_EXPORT void Invert();
//! Inverts this vector and creates a new vector.
Standard_EXPORT math_Vector Inverse() const;
//! sets a vector from "theI1" to "theI2" to the vector "theV";
//! An exception is raised if "theI1" is less than "LowerIndex" or "theI2" is greater than "UpperIndex" or "theI1" is greater than "theI2".
//! An exception is raised if "theI2-theI1+1" is different from the "Length" of "theV".
Standard_EXPORT void Set(const Standard_Integer theI1, const Standard_Integer theI2, const math_Vector& theV);
//!Creates a new vector by inverting the values of this vector
//! between indexes "theI1" and "theI2".
//! If the values of this vector were (1., 2., 3., 4.,5., 6.),
//! by slicing it between indexes 2 and 5 the values
//! of the resulting vector are (1., 5., 4., 3., 2., 6.)
Standard_EXPORT math_Vector Slice(const Standard_Integer theI1, const Standard_Integer theI2) const;
//! returns the product of a vector and a real value.
Standard_EXPORT void Multiply(const Standard_Real theRight);
void operator *=(const Standard_Real theRight)
{
Multiply(theRight);
}
//! returns the product of a vector and a real value.
Standard_EXPORT math_Vector Multiplied(const Standard_Real theRight) const;
math_Vector operator*(const Standard_Real theRight) const
{
return Multiplied(theRight);
}
//! returns the product of a vector and a real value.
Standard_EXPORT math_Vector TMultiplied(const Standard_Real theRight) const;
friend inline math_Vector operator* (const Standard_Real theLeft, const math_Vector& theRight)
{
return theRight.Multiplied(theLeft);
}
//! divides a vector by the value "theRight".
//! An exception is raised if "theRight" = 0.
Standard_EXPORT void Divide(const Standard_Real theRight);
void operator /=(const Standard_Real theRight)
{
Divide(theRight);
}
//! divides a vector by the value "theRight".
//! An exception is raised if "theRight" = 0.
Standard_EXPORT math_Vector Divided(const Standard_Real theRight) const;
math_Vector operator/(const Standard_Real theRight) const
{
return Divided(theRight);
}
//! adds the vector "theRight" to a vector.
//! An exception is raised if the vectors have not the same length.
//! Warning
//! In order to avoid time-consuming copying of vectors, it
//! is preferable to use operator += or the function Add whenever possible.
Standard_EXPORT void Add(const math_Vector& theRight);
void operator +=(const math_Vector& theRight)
{
Add(theRight);
}
//! adds the vector theRight to a vector.
//! An exception is raised if the vectors have not the same length.
//! An exception is raised if the lengths are not equal.
Standard_EXPORT math_Vector Added(const math_Vector& theRight) const;
math_Vector operator+(const math_Vector& theRight) const
{
return Added(theRight);
}
//! sets a vector to the product of the vector "theLeft"
//! with the matrix "theRight".
Standard_EXPORT void Multiply(const math_Vector& theLeft, const math_Matrix& theRight);
//!sets a vector to the product of the matrix "theLeft"
//! with the vector "theRight".
Standard_EXPORT void Multiply(const math_Matrix& theLeft, const math_Vector& theRight);
//! sets a vector to the product of the transpose
//! of the matrix "theTLeft" by the vector "theRight".
Standard_EXPORT void TMultiply(const math_Matrix& theTLeft, const math_Vector& theRight);
//! sets a vector to the product of the vector
//! "theLeft" by the transpose of the matrix "theTRight".
Standard_EXPORT void TMultiply(const math_Vector& theLeft, const math_Matrix& theTRight);
//! sets a vector to the sum of the vector "theLeft"
//! and the vector "theRight".
//! An exception is raised if the lengths are different.
Standard_EXPORT void Add(const math_Vector& theLeft, const math_Vector& theRight);
//! sets a vector to the Subtraction of the
//! vector theRight from the vector theLeft.
//! An exception is raised if the vectors have not the same length.
//! Warning
//! In order to avoid time-consuming copying of vectors, it
//! is preferable to use operator -= or the function
//! Subtract whenever possible.
Standard_EXPORT void Subtract(const math_Vector& theLeft,const math_Vector& theRight);
//! accesses (in read or write mode) the value of index "theNum" of a vector.
inline Standard_Real& Value(const Standard_Integer theNum) const
{
Standard_RangeError_Raise_if(theNum < LowerIndex || theNum > UpperIndex, " ");
return Array(theNum);
}
Standard_Real& operator()(const Standard_Integer theNum) const
{
return Value(theNum);
}
//! Initialises a vector by copying "theOther".
//! An exception is raised if the Lengths are differents.
Standard_EXPORT math_Vector& Initialized(const math_Vector& theOther);
math_Vector& operator=(const math_Vector& theOther)
{
return Initialized(theOther);
}
//! returns the inner product of 2 vectors.
//! An exception is raised if the lengths are not equal.
Standard_EXPORT Standard_Real Multiplied(const math_Vector& theRight) const;
Standard_Real operator*(const math_Vector& theRight) const
{
return Multiplied(theRight);
}
//! returns the product of a vector by a matrix.
Standard_EXPORT math_Vector Multiplied(const math_Matrix& theRight) const;
math_Vector operator*(const math_Matrix& theRight) const
{
return Multiplied(theRight);
}
//! returns the opposite of a vector.
Standard_EXPORT math_Vector Opposite();
math_Vector operator-()
{
return Opposite();
}
//! returns the subtraction of "theRight" from "me".
//! An exception is raised if the vectors have not the same length.
Standard_EXPORT void Subtract(const math_Vector& theRight);
void operator-=(const math_Vector& theRight)
{
Subtract(theRight);
}
//! returns the subtraction of "theRight" from "me".
//! An exception is raised if the vectors have not the same length.
Standard_EXPORT math_Vector Subtracted(const math_Vector& theRight) const;
math_Vector operator-(const math_Vector& theRight) const
{
return Subtracted(theRight);
}
//! returns the multiplication of a real by a vector.
//! "me" = "theLeft" * "theRight"
Standard_EXPORT void Multiply(const Standard_Real theLeft,const math_Vector& theRight);
//! Prints information on the current state of the object.
//! Is used to redefine the operator <<.
Standard_EXPORT void Dump(Standard_OStream& theO) const;
friend inline Standard_OStream& operator<<(Standard_OStream& theO, const math_Vector& theVec)
{
theVec.Dump(theO);
return theO;
}
friend class math_Matrix;
protected:
//! Is used internally to set the "theLower" value of the vector.
void SetLower(const Standard_Integer theLower);
private:
Standard_Integer LowerIndex;
Standard_Integer UpperIndex;
math_SingleTab<Standard_Real> Array;
};
#endif

55
src/math/math_Vector.lxx
View File

@ -1,55 +0,0 @@
// Copyright (c) 1997-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 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.
// lpa, le 29/10/91
#include <Standard_DimensionError.hxx>
inline Standard_OStream& operator<<(Standard_OStream& o,
const math_Vector& vec)
{
vec.Dump(o);
return o;
}
inline math_Vector operator* (const Standard_Real Left,
const math_Vector& Right)
{
return Right.Multiplied(Left);
}
inline Standard_Integer math_Vector::Length() const
{ return UpperIndex - LowerIndex +1;}
// length of a vector.
inline Standard_Integer math_Vector::Lower() const
{ return LowerIndex;}
// value of the lower index of a vector.
inline Standard_Integer math_Vector::Upper() const
{return UpperIndex;}
// value of the Upper index of a vector.
inline Standard_Real& math_Vector::Value(const Standard_Integer Num) const {
Standard_RangeError_Raise_if(Num < LowerIndex || Num > UpperIndex, " ");
return Array(Num);
}