[occt.git] / src / math / math_Vector.cxx

//#ifndef DEB
#define No_Standard_RangeError
#define No_Standard_OutOfRange
#define No_Standard_DimensionError
//#endif

#include <stdio.h>

#include <math_Vector.ixx>
#include <math_Matrix.hxx>

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


math_Vector::math_Vector(const Standard_Integer Lower,
			 const Standard_Integer Upper):
			 
			 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, "");		       
  Array.Init(InitialValue);
}

math_Vector::math_Vector(const Standard_Address Tab,
			 const Standard_Integer Lower,
			 const Standard_Integer Upper) :
			 
			 LowerIndex(Lower),
			 UpperIndex(Upper),
			 Array(*((const Standard_Real *)Tab), Lower,Upper) 
{
  Standard_RangeError_Raise_if((Lower > Upper) , "");		       
}

void math_Vector::Init(const Standard_Real InitialValue) {
  Array.Init(InitialValue);
}

math_Vector::math_Vector(const math_Vector& Other): 

LowerIndex(Other.LowerIndex),
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 {

  Standard_Real Result = 0;

  for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
    Result = Result + Array(Index) * Array(Index);
  }
  return Sqrt(Result);
}

Standard_Real math_Vector::Norm2() const {

  Standard_Real Result = 0;

  for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
    Result = Result + Array(Index) * Array(Index);
  }
  return Result;
}

Standard_Integer math_Vector::Max() const {

  Standard_Integer I=0;
  Standard_Real X = RealFirst();

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

Standard_Integer math_Vector::Min() const {

  Standard_Integer I=0;
  Standard_Real X = RealLast();

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

void math_Vector::Set(const Standard_Integer I1, 
		      const Standard_Integer I2, 
		      const math_Vector &V) {

  Standard_RangeError_Raise_if((I1 < LowerIndex) || 
			       (I2 > UpperIndex) || 
			       (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++;
  }
}

void math_Vector::Normalize() {

  Standard_Real Result = Norm();
  Standard_NullValue_Raise_if((Result <= RealEpsilon()), "");
  for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
    Array(Index) = Array(Index) / Result;
  }
}

math_Vector math_Vector::Normalized() const {

  math_Vector Result = *this;

  Result.Normalize();
  return Result;
}

void math_Vector::Invert() {
  Standard_Integer J;
  Standard_Real Temp;
  for(Standard_Integer Index = LowerIndex; 
//      Index <= LowerIndex + (Length()) >> 1 ; Index++) {
      Index <= (LowerIndex + Length()) >> 1 ; Index++) {
    J = UpperIndex + LowerIndex - Index;
    Temp = Array(Index);
    Array(Index) = Array(J);
    Array(J) = Temp;
  }
}

math_Vector math_Vector::Inverse() const {
  math_Vector Result = *this;
  Result.Invert();
  return Result;
}

math_Vector math_Vector::Multiplied(const Standard_Real Right) const{

  math_Vector Result (LowerIndex, UpperIndex);

  for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
    Result.Array(Index) = Array(Index) * Right;
  }
  return Result;
}

math_Vector math_Vector::TMultiplied(const Standard_Real Right) const{

  math_Vector Result (LowerIndex, UpperIndex);

  for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
    Result.Array(Index) = Array(Index) * Right;
  }
  return Result;
}


void math_Vector::Multiply(const Standard_Real Right) {

  for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
    Array(Index) = Array(Index) * Right;
  }
}


void math_Vector::Divide(const Standard_Real Right) {

  Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), "");

  for(Standard_Integer Index =LowerIndex; Index <=UpperIndex; Index++) {
    Array(Index) = Array(Index) / Right;
  }
}


math_Vector math_Vector::Divided (const Standard_Real Right) const {
  
  Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), "");
  math_Vector temp = Multiplied(1./Right);
  return temp;
}


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_RangeError_Raise_if((I1 < LowerIndex) ||
			       (I1 > UpperIndex) ||
			       (I2 < LowerIndex) ||
			       (I2 > UpperIndex) , "");
  

  if(I2 >= I1) {
    math_Vector Result(I1, I2);
    for(Standard_Integer Index = I1; Index <= I2; Index++) {
      Result.Array(Index) = Array(Index);
    }        
    return Result;  
  }
  else {
    math_Vector Result(I2, I1);
    for(Standard_Integer Index = I1; Index >= I2; Index--) {
      Result.Array(Index) = Array(Index);
    }
    return Result;
  }   
}


void math_Vector::Add (const math_Vector& Left, const math_Vector& Right) {

  Standard_DimensionError_Raise_if((Length() != Right.Length()) ||
				   (Right.Length() != Left.Length()), "");

  
  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++;
    J++;
  }
}    

void math_Vector::Subtract (const math_Vector& Left, 
			    const math_Vector& Right) {

  Standard_DimensionError_Raise_if((Length() != Right.Length()) ||
				   (Right.Length() != Left.Length()), "");
  
  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++;
    J++;
  }
}    

void math_Vector::Multiply(const math_Matrix& Left, 
			   const math_Vector& Right) {

  Standard_DimensionError_Raise_if((Length() != Left.RowNumber()) ||
				   (Left.ColNumber() != Right.Length()),
				   "");

  Standard_Integer Index = LowerIndex;
  for(Standard_Integer I = Left.LowerRowIndex; I <= Left.UpperRowIndex; I++) {
    Array(Index) = 0.0;
    Standard_Integer K = Right.LowerIndex;
    for(Standard_Integer J = Left.LowerColIndex; J <= Left.UpperColIndex; J++) {
      Array(Index) = Array(Index) + Left.Array(I, J) * Right.Array(K);
      K++;
    }
    Index++;
  }
}    

void math_Vector::Multiply(const math_Vector& Left,
			   const math_Matrix& Right) {

  Standard_DimensionError_Raise_if((Length() != Right.ColNumber()) ||
				   (Left.Length() != Right.RowNumber()),
				   "");

  Standard_Integer Index = LowerIndex;
  for(Standard_Integer J = Right.LowerColIndex; J <= Right.UpperColIndex; J++) {
    Array(Index) = 0.0;
    Standard_Integer K = Left.LowerIndex;
    for(Standard_Integer I = Right.LowerRowIndex; I <= Right.UpperRowIndex; I++) {
      Array(Index) = Array(Index) + Left.Array(K) * Right.Array(I, J);
      K++;
    }
    Index++;
  }
}    

void math_Vector::TMultiply(const math_Matrix& TLeft,
			    const math_Vector&  Right) {

  Standard_DimensionError_Raise_if((Length() != TLeft.ColNumber()) ||
				   (TLeft.RowNumber() != Right.Length()),
				   "");

  Standard_Integer Index = LowerIndex;
  for(Standard_Integer I = TLeft.LowerColIndex; I <= TLeft.UpperColIndex; I++) {
    Array(Index) = 0.0;
    Standard_Integer K = Right.LowerIndex;
    for(Standard_Integer J = TLeft.LowerRowIndex; J <= TLeft.UpperRowIndex; J++) {
      Array(Index) = Array(Index) + TLeft.Array(J, I) * Right.Array(K);
      K++;
    }
    Index++;
  }
}    

void math_Vector::TMultiply(const math_Vector&  Left,
			    const math_Matrix& TRight) {

  Standard_DimensionError_Raise_if((Length() != TRight.RowNumber()) ||
				   (Left.Length() != TRight.ColNumber()),
				   "");

  Standard_Integer Index = LowerIndex;
  for(Standard_Integer J = TRight.LowerRowIndex; J <= TRight.UpperRowIndex; J++) {
    Array(Index) = 0.0;
    Standard_Integer K = Left.LowerIndex;
    for(Standard_Integer I = TRight.LowerColIndex; 
	I <= TRight.UpperColIndex; I++) {
      Array(Index) = Array(Index) + Left.Array(K) * TRight.Array(J, I);
      K++;
    }
    Index++;
  }
}    


Standard_Real math_Vector::Multiplied(const math_Vector& Right) const{
  Standard_Real Result = 0;

  Standard_DimensionError_Raise_if(Length() != Right.Length(), "");

  Standard_Integer I = Right.LowerIndex;
  for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
    Result = Result + Array(Index) * Right.Array(I);
    I++;
  }
  return Result;
}    

math_Vector math_Vector::Opposite() {
  math_Vector Result(LowerIndex, UpperIndex);

  for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
    Result.Array(Index) = - Array(Index);
  }
  return Result;
}    

math_Vector math_Vector::Multiplied(const math_Matrix& Right)const {    
  Standard_DimensionError_Raise_if(Length() != Right.RowNumber(), "");

  math_Vector Result(Right.LowerColIndex, Right.UpperColIndex);
  for(Standard_Integer J2 = Right.LowerColIndex; 
      J2 <= Right.UpperColIndex; J2++) {
    Array(J2) = 0.0;
    Standard_Integer I2 = Right.LowerRowIndex;
    for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++) {
      Result.Array(J2) = Result.Array(J2) + Array(I) * 
	Right.Array(I2, J2);
      I2++;
    }
  }
  return Result;
}    


void math_Vector::Multiply(const Standard_Real Left,
			   const math_Vector& Right) 
{
  Standard_DimensionError_Raise_if((Length() != Right.Length()),
				   "");
  for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++) {
    Array(I) = Left * Right.Array(I);
  }
}


math_Vector& math_Vector::Initialized(const math_Vector& Other) {

  Standard_DimensionError_Raise_if(Length() != Other.Length(), "");
  
  (Other.Array).Copy(Array);
  return *this;
}


void math_Vector::Dump(Standard_OStream& o) const
{
  o << "math_Vector of Length = " << Length() << "\n";
  for(Standard_Integer Index = LowerIndex; 
      Index <= UpperIndex; Index++) {
    o << "math_Vector(" << Index << ") = " << Array(Index) << "\n";
  }
}
Commit	Line	Data
	1	//#ifndef DEB
	2	#define No_Standard_RangeError
	3	#define No_Standard_OutOfRange
	4	#define No_Standard_DimensionError
	5	//#endif
	6
	7	#include <stdio.h>
	8
	9	#include <math_Vector.ixx>
	10	#include <math_Matrix.hxx>
	11
	12	#include <Standard_DimensionError.hxx>
	13	#include <Standard_DivideByZero.hxx>
	14	#include <Standard_RangeError.hxx>
	15	#include <Standard_NullValue.hxx>
	16
	17
	18	math_Vector::math_Vector(const Standard_Integer Lower,
	19	const Standard_Integer Upper):
	20
	21	LowerIndex(Lower),
	22	UpperIndex(Upper),
	23	Array(Lower,Upper) {
	24	Standard_RangeError_Raise_if(Lower > Upper, "");
	25	}
	26
	27	math_Vector::math_Vector(const Standard_Integer Lower,
	28	const Standard_Integer Upper,
	29	const Standard_Real InitialValue):
	30
	31	LowerIndex(Lower),
	32	UpperIndex(Upper),
	33	Array(Lower,Upper)
	34	{
	35	Standard_RangeError_Raise_if(Lower > Upper, "");
	36	Array.Init(InitialValue);
	37	}
	38
	39	math_Vector::math_Vector(const Standard_Address Tab,
	40	const Standard_Integer Lower,
	41	const Standard_Integer Upper) :
	42
	43	LowerIndex(Lower),
	44	UpperIndex(Upper),
	45	Array(((const Standard_Real )Tab), Lower,Upper)
	46	{
	47	Standard_RangeError_Raise_if((Lower > Upper) , "");
	48	}
	49
	50	void math_Vector::Init(const Standard_Real InitialValue) {
	51	Array.Init(InitialValue);
	52	}
	53
	54	math_Vector::math_Vector(const math_Vector& Other):
	55
	56	LowerIndex(Other.LowerIndex),
	57	UpperIndex(Other.UpperIndex),
	58	Array(Other.Array) {}
	59
	60
	61	void math_Vector::SetLower(const Standard_Integer Lower) {
	62
	63	Array.SetLower(Lower);
	64	UpperIndex = UpperIndex - LowerIndex + Lower;
	65	LowerIndex = Lower;
	66	}
	67
	68	Standard_Real math_Vector::Norm() const {
	69
	70	Standard_Real Result = 0;
	71
	72	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	73	Result = Result + Array(Index) * Array(Index);
	74	}
	75	return Sqrt(Result);
	76	}
	77
	78	Standard_Real math_Vector::Norm2() const {
	79
	80	Standard_Real Result = 0;
	81
	82	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	83	Result = Result + Array(Index) * Array(Index);
	84	}
	85	return Result;
	86	}
	87
	88	Standard_Integer math_Vector::Max() const {
	89
	90	Standard_Integer I=0;
	91	Standard_Real X = RealFirst();
	92
	93	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	94	if(Array(Index) > X) {
	95	X = Array(Index);
	96	I = Index;
	97	}
	98	}
	99	return I;
	100	}
	101
	102	Standard_Integer math_Vector::Min() const {
	103
	104	Standard_Integer I=0;
	105	Standard_Real X = RealLast();
	106
	107	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	108	if(Array(Index) < X) {
	109	X = Array(Index);
	110	I = Index;
	111	}
	112	}
	113	return I;
	114	}
	115
	116	void math_Vector::Set(const Standard_Integer I1,
	117	const Standard_Integer I2,
	118	const math_Vector &V) {
	119
	120	Standard_RangeError_Raise_if((I1 < LowerIndex) \|\|
	121	(I2 > UpperIndex) \|\|
	122	(I1 > I2) \|\|
	123	(I2 - I1 + 1 != V.Length()), "");
	124
	125	Standard_Integer I = V.Lower();
	126	for(Standard_Integer Index = I1; Index <= I2; Index++) {
	127	Array(Index) = V.Array(I);
	128	I++;
	129	}
	130	}
	131
	132	void math_Vector::Normalize() {
	133
	134	Standard_Real Result = Norm();
	135	Standard_NullValue_Raise_if((Result <= RealEpsilon()), "");
	136	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	137	Array(Index) = Array(Index) / Result;
	138	}
	139	}
	140
	141	math_Vector math_Vector::Normalized() const {
	142
	143	math_Vector Result = *this;
	144
	145	Result.Normalize();
	146	return Result;
	147	}
	148
	149	void math_Vector::Invert() {
	150	Standard_Integer J;
	151	Standard_Real Temp;
	152	for(Standard_Integer Index = LowerIndex;
	153	// Index <= LowerIndex + (Length()) >> 1 ; Index++) {
	154	Index <= (LowerIndex + Length()) >> 1 ; Index++) {
	155	J = UpperIndex + LowerIndex - Index;
	156	Temp = Array(Index);
	157	Array(Index) = Array(J);
	158	Array(J) = Temp;
	159	}
	160	}
	161
	162	math_Vector math_Vector::Inverse() const {
	163	math_Vector Result = *this;
	164	Result.Invert();
	165	return Result;
	166	}
	167
	168	math_Vector math_Vector::Multiplied(const Standard_Real Right) const{
	169
	170	math_Vector Result (LowerIndex, UpperIndex);
	171
	172	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	173	Result.Array(Index) = Array(Index) * Right;
	174	}
	175	return Result;
	176	}
	177
	178	math_Vector math_Vector::TMultiplied(const Standard_Real Right) const{
	179
	180	math_Vector Result (LowerIndex, UpperIndex);
	181
	182	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	183	Result.Array(Index) = Array(Index) * Right;
	184	}
	185	return Result;
	186	}
	187
	188
	189	void math_Vector::Multiply(const Standard_Real Right) {
	190
	191	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	192	Array(Index) = Array(Index) * Right;
	193	}
	194	}
	195
	196
	197	void math_Vector::Divide(const Standard_Real Right) {
	198
	199	Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), "");
	200
	201	for(Standard_Integer Index =LowerIndex; Index <=UpperIndex; Index++) {
	202	Array(Index) = Array(Index) / Right;
	203	}
	204	}
	205
	206
	207	math_Vector math_Vector::Divided (const Standard_Real Right) const {
	208
	209	Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), "");
	210	math_Vector temp = Multiplied(1./Right);
	211	return temp;
	212	}
	213
	214
	215	void math_Vector::Add(const math_Vector& Right) {
	216
	217	Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
	218
	219	Standard_Integer I = Right.LowerIndex;
	220	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	221	Array(Index) = Array(Index) + Right.Array(I);
	222	I++;
	223	}
	224	}
	225
	226	math_Vector math_Vector::Added(const math_Vector& Right) const{
	227
	228	Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
	229
	230	math_Vector Result(LowerIndex, UpperIndex);
	231
	232	Standard_Integer I = Right.LowerIndex;
	233	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	234	Result.Array(Index) = Array(Index) + Right.Array(I);
	235	I++;
	236	}
	237	return Result;
	238	}
	239
	240
	241
	242	void math_Vector::Subtract(const math_Vector& Right) {
	243
	244	Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
	245
	246	Standard_Integer I = Right.LowerIndex;
	247	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	248	Array(Index) = Array(Index) - Right.Array(I);
	249	I++;
	250	}
	251	}
	252
	253
	254	math_Vector math_Vector::Subtracted (const math_Vector& Right) const {
	255
	256	Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
	257
	258	math_Vector Result(LowerIndex, UpperIndex);
	259
	260	Standard_Integer I = Right.LowerIndex;
	261	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	262	Result.Array(Index) = Array(Index) - Right.Array(I);
	263	I++;
	264	}
	265	return Result;
	266	}
	267
	268
	269	math_Vector math_Vector::Slice(const Standard_Integer I1,
	270	const Standard_Integer I2) const
	271	{
	272
	273	Standard_RangeError_Raise_if((I1 < LowerIndex) \|\|
	274	(I1 > UpperIndex) \|\|
	275	(I2 < LowerIndex) \|\|
	276	(I2 > UpperIndex) , "");
	277
	278
	279	if(I2 >= I1) {
	280	math_Vector Result(I1, I2);
	281	for(Standard_Integer Index = I1; Index <= I2; Index++) {
	282	Result.Array(Index) = Array(Index);
	283	}
	284	return Result;
	285	}
	286	else {
	287	math_Vector Result(I2, I1);
	288	for(Standard_Integer Index = I1; Index >= I2; Index--) {
	289	Result.Array(Index) = Array(Index);
	290	}
	291	return Result;
	292	}
	293	}
	294
	295
	296	void math_Vector::Add (const math_Vector& Left, const math_Vector& Right) {
	297
	298	Standard_DimensionError_Raise_if((Length() != Right.Length()) \|\|
	299	(Right.Length() != Left.Length()), "");
	300
	301
	302	Standard_Integer I = Left.LowerIndex;
	303	Standard_Integer J = Right.LowerIndex;
	304	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	305	Array(Index) = Left.Array(I) + Right.Array(J);
	306	I++;
	307	J++;
	308	}
	309	}
	310
	311	void math_Vector::Subtract (const math_Vector& Left,
	312	const math_Vector& Right) {
	313
	314	Standard_DimensionError_Raise_if((Length() != Right.Length()) \|\|
	315	(Right.Length() != Left.Length()), "");
	316
	317	Standard_Integer I = Left.LowerIndex;
	318	Standard_Integer J = Right.LowerIndex;
	319	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	320	Array(Index) = Left.Array(I) - Right.Array(J);
	321	I++;
	322	J++;
	323	}
	324	}
	325
	326	void math_Vector::Multiply(const math_Matrix& Left,
	327	const math_Vector& Right) {
	328
	329	Standard_DimensionError_Raise_if((Length() != Left.RowNumber()) \|\|
	330	(Left.ColNumber() != Right.Length()),
	331	"");
	332
	333	Standard_Integer Index = LowerIndex;
	334	for(Standard_Integer I = Left.LowerRowIndex; I <= Left.UpperRowIndex; I++) {
	335	Array(Index) = 0.0;
	336	Standard_Integer K = Right.LowerIndex;
	337	for(Standard_Integer J = Left.LowerColIndex; J <= Left.UpperColIndex; J++) {
	338	Array(Index) = Array(Index) + Left.Array(I, J) * Right.Array(K);
	339	K++;
	340	}
	341	Index++;
	342	}
	343	}
	344
	345	void math_Vector::Multiply(const math_Vector& Left,
	346	const math_Matrix& Right) {
	347
	348	Standard_DimensionError_Raise_if((Length() != Right.ColNumber()) \|\|
	349	(Left.Length() != Right.RowNumber()),
	350	"");
	351
	352	Standard_Integer Index = LowerIndex;
	353	for(Standard_Integer J = Right.LowerColIndex; J <= Right.UpperColIndex; J++) {
	354	Array(Index) = 0.0;
	355	Standard_Integer K = Left.LowerIndex;
	356	for(Standard_Integer I = Right.LowerRowIndex; I <= Right.UpperRowIndex; I++) {
	357	Array(Index) = Array(Index) + Left.Array(K) * Right.Array(I, J);
	358	K++;
	359	}
	360	Index++;
	361	}
	362	}
	363
	364	void math_Vector::TMultiply(const math_Matrix& TLeft,
	365	const math_Vector& Right) {
	366
	367	Standard_DimensionError_Raise_if((Length() != TLeft.ColNumber()) \|\|
	368	(TLeft.RowNumber() != Right.Length()),
	369	"");
	370
	371	Standard_Integer Index = LowerIndex;
	372	for(Standard_Integer I = TLeft.LowerColIndex; I <= TLeft.UpperColIndex; I++) {
	373	Array(Index) = 0.0;
	374	Standard_Integer K = Right.LowerIndex;
	375	for(Standard_Integer J = TLeft.LowerRowIndex; J <= TLeft.UpperRowIndex; J++) {
	376	Array(Index) = Array(Index) + TLeft.Array(J, I) * Right.Array(K);
	377	K++;
	378	}
	379	Index++;
	380	}
	381	}
	382
	383	void math_Vector::TMultiply(const math_Vector& Left,
	384	const math_Matrix& TRight) {
	385
	386	Standard_DimensionError_Raise_if((Length() != TRight.RowNumber()) \|\|
	387	(Left.Length() != TRight.ColNumber()),
	388	"");
	389
	390	Standard_Integer Index = LowerIndex;
	391	for(Standard_Integer J = TRight.LowerRowIndex; J <= TRight.UpperRowIndex; J++) {
	392	Array(Index) = 0.0;
	393	Standard_Integer K = Left.LowerIndex;
	394	for(Standard_Integer I = TRight.LowerColIndex;
	395	I <= TRight.UpperColIndex; I++) {
	396	Array(Index) = Array(Index) + Left.Array(K) * TRight.Array(J, I);
	397	K++;
	398	}
	399	Index++;
	400	}
	401	}
	402
	403
	404
	405
	406	Standard_Real math_Vector::Multiplied(const math_Vector& Right) const{
	407	Standard_Real Result = 0;
	408
	409	Standard_DimensionError_Raise_if(Length() != Right.Length(), "");
	410
	411	Standard_Integer I = Right.LowerIndex;
	412	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	413	Result = Result + Array(Index) * Right.Array(I);
	414	I++;
	415	}
	416	return Result;
	417	}
	418
	419	math_Vector math_Vector::Opposite() {
	420	math_Vector Result(LowerIndex, UpperIndex);
	421
	422	for(Standard_Integer Index = LowerIndex; Index <= UpperIndex; Index++) {
	423	Result.Array(Index) = - Array(Index);
	424	}
	425	return Result;
	426	}
	427
	428	math_Vector math_Vector::Multiplied(const math_Matrix& Right)const {
	429	Standard_DimensionError_Raise_if(Length() != Right.RowNumber(), "");
	430
	431	math_Vector Result(Right.LowerColIndex, Right.UpperColIndex);
	432	for(Standard_Integer J2 = Right.LowerColIndex;
	433	J2 <= Right.UpperColIndex; J2++) {
	434	Array(J2) = 0.0;
	435	Standard_Integer I2 = Right.LowerRowIndex;
	436	for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++) {
	437	Result.Array(J2) = Result.Array(J2) + Array(I) *
	438	Right.Array(I2, J2);
	439	I2++;
	440	}
	441	}
	442	return Result;
	443	}
	444
	445
	446	void math_Vector::Multiply(const Standard_Real Left,
	447	const math_Vector& Right)
	448	{
	449	Standard_DimensionError_Raise_if((Length() != Right.Length()),
	450	"");
	451	for(Standard_Integer I = LowerIndex; I <= UpperIndex; I++) {
	452	Array(I) = Left * Right.Array(I);
	453	}
	454	}
	455
	456
	457	math_Vector& math_Vector::Initialized(const math_Vector& Other) {
	458
	459	Standard_DimensionError_Raise_if(Length() != Other.Length(), "");
	460
	461	(Other.Array).Copy(Array);
	462	return *this;
	463	}
	464
	465
	466
	467	void math_Vector::Dump(Standard_OStream& o) const
	468	{
	469	o << "math_Vector of Length = " << Length() << "\n";
	470	for(Standard_Integer Index = LowerIndex;
	471	Index <= UpperIndex; Index++) {
	472	o << "math_Vector(" << Index << ") = " << Array(Index) << "\n";
	473	}
	474	}