0024045: Invalid test case for matrix-vector multiplication
[occt.git] / src / math / math_Matrix.cxx
1 // Copyright (c) 1997-1999 Matra Datavision
2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
3 //
4 // The content of this file is subject to the Open CASCADE Technology Public
5 // License Version 6.5 (the "License"). You may not use the content of this file
6 // except in compliance with the License. Please obtain a copy of the License
7 // at http://www.opencascade.org and read it completely before using this file.
8 //
9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11 //
12 // The Original Code and all software distributed under the License is
13 // distributed on an "AS IS" basis, without warranty of any kind, and the
14 // Initial Developer hereby disclaims all such warranties, including without
15 // limitation, any warranties of merchantability, fitness for a particular
16 // purpose or non-infringement. Please see the License for the specific terms
17 // and conditions governing the rights and limitations under the License.
18
19 #include <math_Matrix.ixx>
20 #include <math_Vector.hxx>
21
22 #include <Standard_DimensionError.hxx>
23 #include <Standard_DivideByZero.hxx>
24 #include <Standard_RangeError.hxx>
25 #include <math_SingularMatrix.hxx> 
26 #include <math_NotSquare.hxx>
27 #include <math_Gauss.hxx>
28
29
30 void math_Matrix::SetLowerRow(const Standard_Integer LowerRow) {
31   
32   Array.SetLowerRow(LowerRow);
33   Standard_Integer Rows = RowNumber();
34   LowerRowIndex = LowerRow;
35   UpperRowIndex = LowerRowIndex + Rows - 1;
36 }
37
38 void math_Matrix::SetLowerCol(const Standard_Integer LowerCol) {
39   
40   Array.SetLowerCol(LowerCol);
41   Standard_Integer Cols = ColNumber();
42   LowerColIndex = LowerCol;
43   UpperColIndex = LowerColIndex + Cols - 1;
44 }
45
46 math_Matrix::math_Matrix (const Standard_Integer LowerRow,
47                           const Standard_Integer UpperRow,
48                           const Standard_Integer LowerCol,
49                           const Standard_Integer UpperCol): 
50                           
51                           LowerRowIndex(LowerRow),
52                           UpperRowIndex(UpperRow),
53                           LowerColIndex(LowerCol),
54                           UpperColIndex(UpperCol),
55                           Array(LowerRow, UpperRow,
56                                 LowerCol, UpperCol) 
57 {
58   
59   Standard_RangeError_Raise_if((LowerRow > UpperRow) ||
60                                (LowerCol > UpperCol), "");
61 }
62
63 math_Matrix::math_Matrix (const Standard_Integer LowerRow,
64                           const Standard_Integer UpperRow,
65                           const Standard_Integer LowerCol,
66                           const Standard_Integer UpperCol,
67                           const Standard_Real InitialValue): 
68                           
69                           LowerRowIndex(LowerRow),
70                           UpperRowIndex(UpperRow),
71                           LowerColIndex(LowerCol),
72                           UpperColIndex(UpperCol),
73                           Array(LowerRow, UpperRow,
74                                 LowerCol, UpperCol) 
75 {
76   
77   Standard_RangeError_Raise_if((LowerRow > UpperRow) ||
78                                (LowerCol > UpperCol), "");
79   Array.Init(InitialValue);
80 }
81
82 math_Matrix::math_Matrix (const Standard_Address Tab,
83                           const Standard_Integer LowerRow,
84                           const Standard_Integer UpperRow,
85                           const Standard_Integer LowerCol,
86                           const Standard_Integer UpperCol) :
87                           
88                           LowerRowIndex(LowerRow),
89                           UpperRowIndex(UpperRow),
90                           LowerColIndex(LowerCol),
91                           UpperColIndex(UpperCol),
92                           Array(*((const Standard_Real *)Tab), 
93                                 LowerRow, UpperRow,
94                                 LowerCol, UpperCol) 
95
96   
97   Standard_RangeError_Raise_if((LowerRow > UpperRow) ||
98                                (LowerCol > UpperCol), "");
99 }
100
101 void math_Matrix::Init(const Standard_Real InitialValue) 
102 {
103   Array.Init(InitialValue);
104 }
105
106 math_Matrix::math_Matrix (const math_Matrix& Other): 
107
108 LowerRowIndex(Other.LowerRow()),
109 UpperRowIndex(Other.UpperRow()),
110 LowerColIndex(Other.LowerCol()),
111 UpperColIndex(Other.UpperCol()),
112 Array(Other.Array) 
113 {
114 }
115
116
117
118 math_Matrix math_Matrix::Divided (const Standard_Real Right) const 
119 {
120   Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), "");
121   math_Matrix temp = Multiplied(1./Right);
122   return temp;
123 }
124
125
126 Standard_Real math_Matrix::Determinant() const 
127
128   math_Gauss Sol(*this);
129   
130   if(Sol.IsDone()) {
131     return Sol.Determinant();
132   }
133   else {
134     return 0.0;
135   }
136 }
137
138 void math_Matrix::Transpose() 
139
140   math_NotSquare_Raise_if(RowNumber() != ColNumber(), "");
141   
142   Standard_Integer Row = LowerRowIndex;
143   Standard_Integer Col = LowerColIndex;
144   SetLowerCol(LowerRowIndex);
145   Standard_Real Temp;
146   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
147     for(Standard_Integer J = I; J <= UpperColIndex; J++) {
148       Temp = Array(I, J);
149       Array(I, J) = Array(J, I);
150       Array(J, I) = Temp;
151     }
152   }
153   SetLowerRow(Col);
154   SetLowerCol(Row);
155 }
156
157 math_Matrix math_Matrix::Transposed() const 
158
159   math_Matrix Result(LowerColIndex, UpperColIndex,
160                      LowerRowIndex, UpperRowIndex);
161   
162   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
163     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
164       Result.Array(J, I) = Array(I, J);
165     }
166   }
167   return Result;
168 }
169
170 void math_Matrix::Invert() 
171
172   math_NotSquare_Raise_if(RowNumber() != ColNumber(), "");
173   
174   math_Gauss Sol(*this);
175   if(Sol.IsDone()) {
176     Sol.Invert(*this);
177   }
178   else {
179     math_SingularMatrix::Raise(); // SingularMatrix Exception;
180   }
181 }
182
183 math_Matrix math_Matrix::Inverse() const 
184 {
185   
186   math_Matrix Result = *this;
187   Result.Invert();
188   return Result;
189 }
190
191 void math_Matrix::Multiply (const Standard_Real Right) 
192
193   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
194     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
195       Array(I, J) = Array(I, J) * Right;
196     }
197   }
198 }
199
200 math_Matrix math_Matrix::Multiplied (const Standard_Real Right) const
201
202   math_Matrix Result(LowerRowIndex, UpperRowIndex, 
203                      LowerColIndex, UpperColIndex);
204   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
205     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
206       Result.Array(I, J) = Array(I, J) * Right;
207     }
208   }
209   return Result;
210 }
211
212 math_Matrix math_Matrix::TMultiplied (const Standard_Real Right) const
213
214   math_Matrix Result(LowerRowIndex, UpperRowIndex, 
215                      LowerColIndex, UpperColIndex);
216   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
217     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
218       Result.Array(I, J) = Array(I, J) * Right;
219     }
220   }
221   return Result;
222 }
223
224
225
226 void math_Matrix::Divide (const Standard_Real Right) 
227
228   Standard_DivideByZero_Raise_if(Abs(Right) <= RealEpsilon(), "");
229   
230   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
231     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
232       Array(I, J) = Array(I, J) / Right;
233     }
234   }
235 }
236
237 void math_Matrix::Add (const math_Matrix& Right) 
238 {
239   Standard_DimensionError_Raise_if((RowNumber() != Right.RowNumber()) ||
240                                    (ColNumber() != Right.ColNumber()),
241                                    "");
242   
243   Standard_Integer I2 = Right.LowerRowIndex;
244   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
245     Standard_Integer J2 = Right.LowerColIndex;
246     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
247       Array(I, J) = Array(I, J) + Right.Array(I2, J2);
248       J2++;
249     }
250     I2++;
251   }
252 }
253
254 void math_Matrix::Subtract (const math_Matrix& Right) 
255
256   Standard_DimensionError_Raise_if((RowNumber() != Right.RowNumber()) ||
257                                    (ColNumber() != Right.ColNumber()),
258                                    "");
259   
260   Standard_Integer I2 = Right.LowerRowIndex;
261   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
262     Standard_Integer J2 = Right.LowerColIndex;
263     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
264       Array(I, J) = Array(I, J) - Right.Array(I2, J2);
265       J2++;
266     }
267     I2++;
268   }
269 }
270
271 void math_Matrix::Set(const Standard_Integer I1,const Standard_Integer I2,
272                       const Standard_Integer J1,const Standard_Integer J2,
273                       const math_Matrix& M) 
274 {
275   
276   Standard_DimensionError_Raise_if((I1 < LowerRowIndex)       || 
277                                    (I2 > UpperRowIndex)       ||
278                                    (J1 < LowerColIndex)       ||
279                                    (J2 > UpperColIndex)       ||
280                                    (I1 > I2) || (J1 > J2)     ||
281                                    (I2-I1+1 != M.RowNumber()) ||
282                                    (J2-J1+1 != M.ColNumber()), "");
283   
284   Standard_Integer II = M.LowerRow();
285   for(Standard_Integer I = I1; I <= I2; I++) {
286     Standard_Integer JJ = M.LowerCol();
287     for(Standard_Integer J = J1; J <= J2; J++) {
288       Array(I, J) = M.Array(II, JJ);
289       JJ++;
290     }
291     II++;
292   }
293 }         
294
295 void math_Matrix::SetRow (const Standard_Integer Row,
296                           const math_Vector& V) 
297
298   
299   Standard_RangeError_Raise_if((Row < LowerRowIndex) ||
300                                (Row > UpperRowIndex) , "");
301   
302   Standard_DimensionError_Raise_if(ColNumber() != V.Length(), "");
303   
304   Standard_Integer I = V.LowerIndex;
305   for(Standard_Integer Index = LowerColIndex; Index <= UpperColIndex; Index++) {
306     Array(Row, Index) = V.Array(I);
307     I++;
308   }
309 }
310
311 void math_Matrix::SetCol (const Standard_Integer Col,
312                           const math_Vector& V) 
313
314   
315   Standard_RangeError_Raise_if((Col < LowerColIndex) ||
316                                (Col > UpperColIndex) , "");
317   
318   Standard_DimensionError_Raise_if(RowNumber() != V.Length(), "");
319   
320   Standard_Integer I = V.LowerIndex;
321   for(Standard_Integer Index = LowerRowIndex; Index <= UpperRowIndex; Index++) {
322     Array(Index, Col) = V.Array(I);
323     I++;
324   }
325 }
326
327 void math_Matrix::SetDiag(const Standard_Real Value)
328
329   
330   math_NotSquare_Raise_if(RowNumber() != ColNumber(), "");
331   
332   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
333     Array(I, I) = Value;
334   }
335 }
336 math_Vector math_Matrix::Row (const Standard_Integer Row)  const 
337
338   
339   math_Vector Result(LowerColIndex, UpperColIndex);
340   
341   for(Standard_Integer Index = LowerColIndex; Index <= UpperColIndex; Index++) {
342     Result.Array(Index) = Array(Row, Index);
343   }
344   return Result;
345 }
346
347 math_Vector math_Matrix::Col (const Standard_Integer Col) const 
348
349   
350   math_Vector Result(LowerRowIndex, UpperRowIndex);
351   
352   for(Standard_Integer Index = LowerRowIndex; Index <= UpperRowIndex; Index++) {
353     Result.Array(Index) = Array(Index, Col);
354   }
355   return Result;
356 }
357
358 void math_Matrix::SwapRow(const Standard_Integer Row1,
359                           const Standard_Integer Row2) 
360 {
361   
362   Standard_RangeError_Raise_if((Row1 < LowerRowIndex) ||
363                                (Row1 > UpperRowIndex) ||
364                                (Row2 < LowerRowIndex) ||
365                                (Row2 > UpperRowIndex), "");
366   
367   math_Vector V1 = Row(Row1);
368   math_Vector V2 = Row(Row2);
369   SetRow(Row1,V2);
370   SetRow(Row2,V1);
371 }
372
373 void math_Matrix::SwapCol(const Standard_Integer Col1,
374                           const Standard_Integer Col2) 
375 {
376   
377   Standard_RangeError_Raise_if((Col1 < LowerColIndex) ||
378                                (Col1 > UpperColIndex) ||
379                                (Col2 < LowerColIndex) ||
380                                (Col2 > UpperColIndex), "");
381   
382   math_Vector V1 = Col(Col1);
383   math_Vector V2 = Col(Col2);
384   SetCol(Col1,V2);
385   SetCol(Col2,V1);
386 }
387
388
389
390 math_Matrix  math_Matrix::Multiplied (const math_Matrix& Right) const 
391
392   
393   Standard_DimensionError_Raise_if(ColNumber() != Right.RowNumber(), "");
394   
395   math_Matrix Result(LowerRowIndex,       UpperRowIndex,
396                      Right.LowerColIndex, Right.UpperColIndex);
397   
398   Standard_Real Som;
399   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
400     for(Standard_Integer J2 = Right.LowerColIndex; J2 <= Right.UpperColIndex; J2++) {
401       Som = 0.0;
402       Standard_Integer I2 = Right.LowerRowIndex;
403       for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
404         Som = Som + Array(I, J) * Right.Array(I2, J2);
405         I2++;
406       }
407       Result.Array(I, J2) = Som;
408     }
409   }
410   return Result;
411 }
412
413 math_Matrix  math_Matrix::TMultiply (const math_Matrix& Right) const 
414
415   
416   Standard_DimensionError_Raise_if(RowNumber() != Right.RowNumber(), "");
417   
418   math_Matrix Result(LowerColIndex,       UpperColIndex,
419                      Right.LowerColIndex, Right.UpperColIndex);
420   
421   Standard_Real Som;
422   for(Standard_Integer I = LowerColIndex; I <= UpperColIndex; I++) {
423     for(Standard_Integer J2 = Right.LowerColIndex; J2 <= Right.UpperColIndex; J2++) {
424       Som = 0.0;
425       Standard_Integer I2 = Right.LowerRowIndex;
426       for(Standard_Integer J = LowerRowIndex; J <= UpperRowIndex; J++) {
427         Som = Som + Array(J, I) * Right.Array(I2, J2);
428         I2++;
429       }
430       Result.Array(I, J2) = Som;
431     }
432   }
433   return Result;
434 }
435
436 math_Matrix  math_Matrix::Added (const math_Matrix& Right) const 
437
438   
439   Standard_DimensionError_Raise_if((RowNumber() != Right.RowNumber()) ||
440                                    (ColNumber() != Right.ColNumber()),
441                                    "");
442   
443   math_Matrix Result(LowerRowIndex, UpperRowIndex, 
444                      LowerColIndex, UpperColIndex);
445   
446   Standard_Integer I2 = Right.LowerRowIndex;
447   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
448     Standard_Integer J2 = Right.LowerColIndex;
449     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
450       Result.Array(I, J) = Array(I, J) + Right.Array(I2, J2);
451       J2++;
452     }
453     I2++;
454   }
455   return Result;
456 }
457
458 math_Matrix  math_Matrix::Opposite () 
459
460   
461   math_Matrix Result(LowerRowIndex, UpperRowIndex, 
462                      LowerColIndex, UpperColIndex);
463   
464   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
465     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
466       Result.Array(I, J) = - Array(I, J);
467     }
468   }
469   return Result;
470 }
471
472 math_Matrix  math_Matrix::Subtracted (const math_Matrix& Right) const 
473
474   
475   Standard_DimensionError_Raise_if((RowNumber() != Right.RowNumber()) ||
476                                    (ColNumber() != Right.ColNumber()),
477                                    "");
478   
479   math_Matrix Result(LowerRowIndex, UpperRowIndex, 
480                      LowerColIndex, UpperColIndex);
481   
482   Standard_Integer I2 = Right.LowerRowIndex;
483   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
484     Standard_Integer J2 = Right.LowerColIndex;
485     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
486       Result.Array(I, J) = Array(I, J) - Right.Array(I2, J2);
487       J2++;
488     }
489     I2++;
490   }
491   return Result;
492 }
493
494 void  math_Matrix::Multiply(const math_Vector&  Left, 
495                             const math_Vector&  Right) 
496 {
497   
498   Standard_DimensionError_Raise_if((RowNumber() != Left.Length()) ||
499                                    (ColNumber() != Right.Length()),
500                                    "");
501   
502   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
503     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
504       Array(I, J) = Left.Array(I) * Right.Array(J);
505     }
506   }
507 }
508
509 void  math_Matrix::Multiply(const math_Matrix&  Left, 
510                             const math_Matrix&  Right) 
511 {
512   
513   Standard_DimensionError_Raise_if((Left.ColNumber() != Right.RowNumber()) ||
514                                    (RowNumber() != Left.RowNumber()) ||
515                                    (ColNumber() != Right.ColNumber()),
516                                    "");
517   
518   Standard_Real Som;
519   Standard_Integer I1 = Left.LowerRowIndex;
520   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
521     Standard_Integer J2 = Right.LowerColIndex;  
522     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
523       Som = 0.0;
524       Standard_Integer J1 = Left.LowerColIndex;
525       Standard_Integer I2 = Right.LowerRowIndex;
526       for(Standard_Integer K = Left.LowerColIndex; K <= Left.UpperColIndex; K++) {
527         Som = Som + Left.Array(I1, J1) * Right.Array(I2, J2);
528         J1++;
529         I2++;
530       }
531       Array(I, J) = Som;
532       J2++;
533     }
534     I1++;
535   }
536 }
537
538 void math_Matrix::TMultiply(const math_Matrix& TLeft, 
539                             const math_Matrix&  Right) 
540 {
541   
542   Standard_DimensionError_Raise_if((TLeft.RowNumber() != Right.RowNumber()) ||
543                                    (RowNumber() != TLeft.ColNumber()) ||
544                                    (ColNumber() != Right.ColNumber()),
545                                    "");
546   
547   Standard_Real Som;
548   Standard_Integer I1 = TLeft.LowerColIndex;
549   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
550     Standard_Integer J2 = Right.LowerColIndex;  
551     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
552       Som = 0.0;
553       Standard_Integer J1 = TLeft.LowerRowIndex;
554       Standard_Integer I2 = Right.LowerRowIndex;
555       for(Standard_Integer K = TLeft.LowerRowIndex; K <= TLeft.UpperRowIndex; K++) {
556         Som = Som + TLeft.Array(J1, I1) * Right.Array(I2, J2);
557         J1++;
558         I2++;
559       }
560       Array(I, J) = Som;
561       J2++;
562     }
563     I1++;
564   }
565 }
566
567 void  math_Matrix::Add (const math_Matrix&  Left, 
568                         const math_Matrix&  Right) 
569 {
570   
571   Standard_DimensionError_Raise_if((RowNumber() != Right.RowNumber()) ||
572                                    (ColNumber() != Right.ColNumber()) ||
573                                    (Right.RowNumber() != Left.RowNumber()) ||
574                                    (Right.ColNumber() != Left.ColNumber()),
575                                    "");
576   
577   Standard_Integer I1 = Left.LowerRowIndex;
578   Standard_Integer I2 = Right.LowerRowIndex;
579   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
580     Standard_Integer J1 = Left.LowerColIndex;
581     Standard_Integer J2 = Right.LowerColIndex;
582     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
583       Array(I, J) = Left.Array(I1, J1) + Right.Array(I2, J2);
584       J1++;
585       J2++;
586     }
587     I1++;
588     I2++;
589   }
590 }
591
592 void  math_Matrix::Subtract(const math_Matrix&  Left,
593                             const math_Matrix&  Right) 
594 {
595   
596   Standard_DimensionError_Raise_if((RowNumber() != Right.RowNumber()) ||
597                                    (ColNumber() != Right.ColNumber()) ||
598                                    (Right.RowNumber() != Left.RowNumber()) ||
599                                    (Right.ColNumber() != Left.ColNumber()),
600                                    "");
601   
602   Standard_Integer I1 = Left.LowerRowIndex;
603   Standard_Integer I2 = Right.LowerRowIndex;
604   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
605     Standard_Integer J1 = Left.LowerColIndex;
606     Standard_Integer J2 = Right.LowerColIndex;
607     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
608       Array(I, J) = Left.Array(I1, J1) - Right.Array(I2, J2);
609       J1++;
610       J2++;
611     }
612     I1++;
613     I2++;
614   }
615 }
616
617
618 void math_Matrix::Multiply(const math_Matrix& Right) 
619 {
620   
621   Standard_DimensionError_Raise_if(ColNumber() != Right.RowNumber(), "");
622   
623   Standard_Real Som;
624   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
625     for(Standard_Integer J2 = Right.LowerColIndex; J2 <= Right.UpperColIndex; J2++) {
626       Som = 0.0;
627       Standard_Integer I2 = Right.LowerRowIndex;
628       for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
629         Som = Som + Array(I, J) * Right.Array(I2, J2);
630         I2++;
631       }
632       Array(I, J2) = Som;
633     }
634   }
635 }
636
637
638
639 math_Vector math_Matrix::Multiplied(const math_Vector& Right)const
640 {
641   
642   Standard_DimensionError_Raise_if(ColNumber() != Right.Length(), "");
643   
644   math_Vector Result(LowerRowIndex, UpperRowIndex);
645   
646   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
647     Result.Array(I) = 0.0;
648     Standard_Integer II = Right.LowerIndex;
649     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
650       Result.Array(I) = Result.Array(I) + Array(I, J) * Right.Array(II);
651       II++;
652     }
653   }
654   return Result;
655 }
656
657 math_Matrix& math_Matrix::Initialized(const math_Matrix& Other) 
658 {
659   
660   Standard_DimensionError_Raise_if((RowNumber() != Other.RowNumber()) ||
661                                    (ColNumber() != Other.ColNumber()), "");
662   
663   (Other.Array).Copy(Array);
664   return *this;
665 }
666
667
668
669
670 void math_Matrix::Dump(Standard_OStream& o)const
671
672 {
673   o << "math_Matrix of RowNumber = " << RowNumber();
674   o << " and ColNumber = " << ColNumber() << "\n";
675   
676   for(Standard_Integer I = LowerRowIndex; I <= UpperRowIndex; I++) {
677     for(Standard_Integer J = LowerColIndex; J <= UpperColIndex; J++) {
678       o << "math_Matrix ( " << I << ", " << J << " ) = ";
679       o << Array(I, J) << "\n";
680     }
681   }
682 }
683