Merge "Fix Dataset for exception case" into tizen_2.1
[platform/framework/native/appfw.git] / src / base / FBaseIntMatrix.cpp
1 //
2 // Open Service Platform
3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
4 //
5 // Licensed under the Apache License, Version 2.0 (the License);
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 //     http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17
18 /**
19  * @file        FBaseIntMatrix.cpp
20  * @brief       This is the implementation for IntMatrix class.
21  */
22
23 #include <FBaseIntMatrix.h>
24 #include <FBaseSysLog.h>
25 #include <unique_ptr.h>
26
27 namespace Tizen { namespace Base
28 {
29
30 IntMatrix::IntMatrix(void)
31         : __pImpl(null)
32         , __pMatrix(null)
33         , __row(0)
34         , __column(0)
35 {
36 }
37
38 IntMatrix::IntMatrix(const IntMatrix& rhs)
39         : __pImpl(null)
40         , __row(rhs.__row)
41         , __column(rhs.__column)
42 {
43         AllocateCapacity(__row, __column);
44         for (int i = 0; i < __row; i++)
45         {
46                 for (int j = 0; j < __column; j++)
47                 {
48                         __pMatrix[i][j] = rhs.__pMatrix[i][j];
49                 }
50         }
51 }
52
53 IntMatrix::IntMatrix(int rowCount, int columnCount)
54         : __pImpl(null)
55         , __row(rowCount)
56         , __column(columnCount)
57 {
58         AllocateCapacity(__row, __column);
59         SetAsNull();
60 }
61
62 IntMatrix::IntMatrix(int rowCount, int columnCount, const int* pArray, bool rowMajor)
63         : __pImpl(null)
64         , __row(rowCount)
65         , __column(columnCount)
66 {
67         AllocateCapacity(__row, __column);
68         if (pArray != null)
69         {
70                 if (rowMajor == true)
71                 {
72                         for (int i = 0; i < __row; i++)
73                         {
74                                 for (int j = 0; j < __column; j++)
75                                 {
76                                         __pMatrix[i][j] = pArray[i * __column + j];
77                                 }
78                         }
79                 }
80                 else
81                 {
82                         for (int i = 0; i < __column; i++)
83                         {
84                                 for (int j = 0; j < __row; j++)
85                                 {
86                                         __pMatrix[j][i] = pArray[i * __row + j];
87                                 }
88                         }
89                 }
90         }
91         else
92         {
93                 SetAsNull();
94         }
95 }
96
97 IntMatrix::IntMatrix(int rowCount, int columnCount, const int* pArray[])
98         : __pImpl(null)
99         , __row(rowCount)
100         , __column(columnCount)
101 {
102         AllocateCapacity(__row, __column);
103         if (pArray != null)
104         {
105                 for (int i = 0; i < __row; i++)
106                 {
107                         for (int j = 0; j < __column; j++)
108                         {
109                                 __pMatrix[i][j] = pArray[i][j];
110                         }
111                 }
112         }
113         else
114         {
115                 SetAsIdentity();
116         }
117 }
118
119 IntMatrix::~IntMatrix(void)
120 {
121         for ( int i = 0 ; i < __row ; i++ )
122         {
123                 delete[] __pMatrix[i];
124         }
125
126         delete[] __pMatrix;
127 }
128
129 bool
130 IntMatrix::operator ==(const IntMatrix& rhs) const
131 {
132         if (this == &rhs)
133         {
134                 return true;
135         }
136
137         if ((__row != rhs.__row) || (__column != rhs.__column))
138         {
139                 return false;
140         }
141
142         for (int i = 0; i < __row; i++)
143         {
144                 for (int j = 0; j < __column; j++)
145                 {
146                         if (__pMatrix[i][j] != rhs.__pMatrix[i][j])
147                         {
148                                 return false;
149                         }
150                 }
151         }
152
153         return true;
154 }
155
156 bool
157 IntMatrix::operator !=(const IntMatrix& rhs) const
158 {
159         return !(*this == rhs);
160 }
161
162 IntMatrix&
163 IntMatrix::operator =(const IntMatrix& rhs)
164 {
165         if (this == &rhs)
166         {
167                 return *this;
168         }
169
170         SysTryReturn(NID_BASE, (__row == rhs.__row) && (__column == rhs.__column), *this, E_INVALID_ARG,
171                 "[%s] Invalid argument is used. Either row or column count of the current instance is not same with that of the specified instance.",
172                 GetErrorMessage(E_INVALID_ARG));
173
174         for (int i = 0; i < __row; i++)
175         {
176                 for (int j = 0; j < __column; j++)
177                 {
178                         __pMatrix[i][j] = rhs.__pMatrix[i][j];
179                 }
180         }
181
182         return *this;
183 }
184
185 bool
186 IntMatrix::Equals(const Tizen::Base::Object& obj) const
187 {
188         const IntMatrix* pOther = dynamic_cast <const IntMatrix*>(&obj);
189
190         if (pOther == null)
191         {
192                 return false;
193         }
194
195         return (*this == *pOther);
196 }
197
198 int
199 IntMatrix::GetHashCode(void) const
200 {
201         int hash = 0;
202         for (int i = 0; i < __row; i++)
203         {
204                 for (int j = 0; j < __column; j++)
205                 {
206                         hash = hash + Tizen::Base::Integer(__pMatrix[i][j]).GetHashCode();
207                 }
208         }
209
210         return hash;
211 }
212
213 result
214 IntMatrix::Add(const IntMatrix& matrix)
215 {
216         SysTryReturnResult(NID_BASE, (__row == matrix.__row) && (__column == matrix.__column), E_INVALID_ARG,
217                 "Either row or column count of the current instance is not same with that of the specified instance.");
218
219         for (int i = 0; i < __row; i++)
220         {
221                 for (int j = 0; j < __column; j++)
222                 {
223                         __pMatrix[i][j] = __pMatrix[i][j] + matrix.__pMatrix[i][j];
224                 }
225         }
226
227         return E_SUCCESS;
228 }
229
230 void
231 IntMatrix::AddToEachElement(int value)
232 {
233         for (int i = 0; i < __row; i++)
234         {
235                 for (int j = 0; j < __column; j++)
236                 {
237                         __pMatrix[i][j] = __pMatrix[i][j] + value;
238                 }
239         }
240 }
241
242 bool
243 IntMatrix::AllocateCapacity(int rowCount, int columnCount)
244 {
245         std::unique_ptr<int* []> pMatrix(new (std::nothrow) int* [rowCount]);
246         SysTryReturn(NID_BASE, pMatrix != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
247                 GetErrorMessage(E_OUT_OF_MEMORY));
248
249         for ( int i = 0 ; i < rowCount ; i++ )
250         {
251                 pMatrix[i] = new (std::nothrow) int[columnCount];
252                 if (pMatrix[i] == null)
253                 {
254                         for (int j = 0; j < i;  j++)
255                         {
256                                 delete[] pMatrix[j];
257                         }
258                         return  false;
259                 }
260         }
261
262         __pMatrix = pMatrix.release();
263
264         return true;
265 }
266
267 int
268 IntMatrix::CalculateDeterminant(int** pMatrix, int order) const  // For perfomance, we have to change the logic of recursive to LU decomposition.
269 {
270         SysTryReturn(NID_BASE, pMatrix != null, 0, E_INVALID_ARG, "[%s] Invalid argument is used. pMatrix is null.",
271                 GetErrorMessage(E_INVALID_ARG));
272
273         if (order == 1)
274         {
275                 return pMatrix[0][0];
276         }
277
278         int determinant = 0;
279         std::unique_ptr<int* []> pMinor(new (std::nothrow) int* [order - 1]);
280         SysTryReturn(NID_BASE, pMinor != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
281                 GetErrorMessage(E_OUT_OF_MEMORY));
282         for (int i = 0; i < order -1; i++)
283         {
284                 pMinor[i] = new (std::nothrow) int[order - 1];
285                 if (pMinor[i] == null)
286                 {
287                         for (int j = 0; j < i;  j++)
288                         {
289                                 delete[] pMinor[j];
290                         }
291                         return  determinant;
292                 }
293         }
294
295         bool signFlag = true;
296         for (int i = 0; i < order; i++)
297         {
298                 GetMinor(pMatrix, pMinor.get(), 0, i, order);
299
300                 if (signFlag == true)
301                 {
302                         determinant += pMatrix[0][i] * CalculateDeterminant(pMinor.get(), order -1);
303                         signFlag = false;
304                 }
305                 else
306                 {
307                         determinant += -pMatrix[0][i] * CalculateDeterminant(pMinor.get(), order -1);
308                         signFlag = true;
309                 }
310         }
311
312         for (int i = 0; i < order -1; i++)
313         {
314                 delete[] pMinor[i];
315         }
316
317         return determinant;
318 }
319
320 int
321 IntMatrix::GetColumnCount(void) const
322 {
323         return __column;
324 }
325
326 int*
327 IntMatrix::GetColumnN(int columnIndex) const
328 {
329         SysTryReturn(NID_BASE, columnIndex <= __column, null, E_INVALID_ARG,
330                 "[%s] Invalid argument is used. The columnIndex is larger than the column count of the current instance.",
331                 GetErrorMessage(E_INVALID_ARG));
332
333         std::unique_ptr<int []> pColumn(new (std::nothrow) int [__row]);
334         SysTryReturn(NID_BASE, pColumn != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
335                 GetErrorMessage(E_OUT_OF_MEMORY));
336
337         for (int i = 0; i < __row; i++)
338         {
339                 pColumn[i] = __pMatrix[i][columnIndex];
340         }
341
342         return pColumn.release();
343 }
344
345 int
346 IntMatrix::GetDeterminant(void) const
347 {
348         SysTryReturn(NID_BASE, __row == __column, 0, E_INVALID_OPERATION,
349                 "[%s] The current instance is not a square matrix.", GetErrorMessage(E_INVALID_OPERATION));
350
351         return CalculateDeterminant(__pMatrix, __row);
352 }
353
354 int
355 IntMatrix::GetElement(int rowIndex, int columnIndex) const
356 {
357         SysTryReturn(NID_BASE, (rowIndex <= __row) && (columnIndex <= __column), 0, E_INVALID_ARG,
358                 "[%s] Invalid argument is used. The current instance is not a square matrix.", GetErrorMessage(E_INVALID_ARG));
359
360         return __pMatrix[rowIndex][columnIndex];
361 }
362
363 IntMatrix*
364 IntMatrix::GetInverseN(void) const
365 {
366         SysTryReturn(NID_BASE, __row == __column, null, E_INVALID_OPERATION,
367                 "[%s] The current instance is not a square matrix.", GetErrorMessage(E_INVALID_OPERATION));
368
369         std::unique_ptr<IntMatrix> pInverseMatrix(new (std::nothrow) IntMatrix(__row, __column));
370         SysTryReturn(NID_BASE, pInverseMatrix != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
371                 GetErrorMessage(E_OUT_OF_MEMORY));
372
373         int determinant = CalculateDeterminant(__pMatrix, __row);
374
375         if (determinant == 0)
376         {
377                 return null;
378         }
379
380         std::unique_ptr<int* []> pMinor(new (std::nothrow) int* [__row - 1]);
381         SysTryReturn(NID_BASE, pMinor != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
382                 GetErrorMessage(E_OUT_OF_MEMORY));
383
384         for (int i = 0; i < __row - 1; i++)
385         {
386                 pMinor[i] = new (std::nothrow) int[__row - 1];
387                 if (pMinor[i] == null)
388                 {
389                         for (int j = 0; j < i;  j++)
390                         {
391                                 delete[] pMinor[j];
392                         }
393                         return null;
394                 }
395         }
396
397         for (int i = 0; i < __row; i++)
398         {
399                 for (int j = 0; j < __row; j++)
400                 {
401                         GetMinor(__pMatrix, pMinor.get(), i, j, __row);
402                         pInverseMatrix->__pMatrix[j][i] = CalculateDeterminant(pMinor.get(), __row - 1) / determinant;
403                         if ((i + j + 2) % 2 == 1)
404                         {
405                                 pInverseMatrix->__pMatrix[j][i] = -pInverseMatrix->__pMatrix[j][i];
406                         }
407                 }
408         }
409
410         for ( int i = 0 ; i < __row - 1 ; i++)
411         {
412                 delete[] pMinor[i];
413         }
414
415         return pInverseMatrix.release();
416 }
417
418 void
419 IntMatrix::GetMinor(int** pSrc, int** pDest, int rowIndex, int columnIndex, int order) const
420 {
421         SysTryReturn(NID_BASE, pSrc != null, , E_INVALID_ARG, "[%s] Invalid argument is used. pSrc is null.",
422                 GetErrorMessage(E_INVALID_ARG));
423         SysTryReturn(NID_BASE, pDest != null, , E_INVALID_ARG, "[%s] Invalid argument is used. pDest is null.",
424                 GetErrorMessage(E_INVALID_ARG));
425
426         int rowCount = 0;
427         int columnCount = 0;
428
429         for (int i = 0; i < order; i++)
430         {
431                 if (i != rowIndex)
432                 {
433                         columnCount = 0;
434
435                         for (int j = 0; j < order; j++)
436                         {
437                                 if (j != columnIndex)
438                                 {
439                                         pDest[rowCount][columnCount] = pSrc[i][j];
440                                         columnCount++;
441                                 }
442                         }
443                         rowCount++;
444                 }
445         }
446 }
447
448 int
449 IntMatrix::GetRowCount(void) const
450 {
451         return __row;
452 }
453
454 int*
455 IntMatrix::GetRowN(int rowIndex) const
456 {
457         SysTryReturn(NID_BASE, rowIndex <= __row, null, E_INVALID_ARG,
458                 "[%s] Invalid argument is used. The rowIndex is larger than the row count of the current instance.",
459                 GetErrorMessage(E_INVALID_ARG));
460
461         std::unique_ptr<int []> pRow(new (std::nothrow) int [__column]);
462         SysTryReturn(NID_BASE, pRow != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
463                 GetErrorMessage(E_OUT_OF_MEMORY));
464
465         for (int i = 0; i < __column; i++)
466         {
467                 pRow[i] = __pMatrix[rowIndex][i];
468         }
469
470         return pRow.release();
471 }
472
473 result
474 IntMatrix::GetTrace(int& value) const
475 {
476         SysTryReturnResult(NID_BASE, __row == __column, E_INVALID_OPERATION, "The current instance is not a square matrix.");
477
478         value = 0;
479
480         for (int i = 0; i < __row; i++)
481         {
482                 value += __pMatrix[i][i];
483         }
484
485         return E_SUCCESS;
486 }
487
488 IntMatrix*
489 IntMatrix::GetTransposeN(void) const
490 {
491         SysTryReturn(NID_BASE, __row == __column, null, E_INVALID_OPERATION,
492                 "[%s] The current instance is not a square matrix.", GetErrorMessage(E_INVALID_OPERATION));
493
494         std::unique_ptr<IntMatrix> pTransposeMatrix(new (std::nothrow) IntMatrix(*this));
495         SysTryReturn(NID_BASE, pTransposeMatrix != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
496                 GetErrorMessage(E_OUT_OF_MEMORY));
497
498         int columnIndex = 1;
499
500         for (int i = 0; i < __row; i++)
501         {
502                 for (int j = 0; j < columnIndex; j++)
503                 {
504                         int temp = pTransposeMatrix->__pMatrix[i][j];
505                         pTransposeMatrix->__pMatrix[i][j] = pTransposeMatrix->__pMatrix[j][i];
506                         pTransposeMatrix->__pMatrix[j][i] = temp;
507                 }
508
509                 columnIndex++;
510         }
511
512         return pTransposeMatrix.release();
513 }
514
515 bool
516 IntMatrix::IsIdentity(void) const
517 {
518         if (__row != __column)
519         {
520                 return false;
521         }
522
523         for (int i = 0; i < __row; i++)
524         {
525                 for (int j = 0; j < __column; j++)
526                 {
527                         if (i == j)
528                         {
529                                 if (__pMatrix[i][j] != 1)
530                                 {
531                                         return false;
532                                 }
533                         }
534                         else
535                         {
536                                 if (__pMatrix[i][j] != 0)
537                                 {
538                                         return false;
539                                 }
540                         }
541                 }
542         }
543         return true;
544 }
545
546 bool
547 IntMatrix::IsInvertible(void) const
548 {
549         int ret = GetDeterminant();
550
551         if (ret == 0)
552         {
553                 return false;
554         }
555         else
556         {
557                 return true;
558         }
559 }
560
561 result
562 IntMatrix::Multiply(const IntMatrix& matrix)
563 {
564         SysTryReturnResult(NID_BASE, __column == matrix.__row, E_INVALID_ARG,
565                 "The column count of the current instance is not same with the row count of the specified instance.");
566
567         std::unique_ptr<int* []> pResult(new (std::nothrow) int* [__row]);
568         SysTryReturnResult(NID_BASE, pResult != null, E_OUT_OF_MEMORY, "Memory allocation failed.");
569
570         for ( int i = 0 ; i < __row ; i++ )
571         {
572                 pResult[i] = new int[matrix.__column];
573                 if (pResult[i] == null)
574                 {
575                         for (int j = 0; j < i;  j++)
576                         {
577                                 delete[] pResult[j];
578                         }
579                         return E_OUT_OF_MEMORY;
580                 }
581         }
582
583         for (int i = 0; i < __row; i++)
584         {
585                 for (int j = 0; j < matrix.__column; j++)
586                 {
587                         pResult[i][j] = 0;
588
589                         for (int k = 0; k < __column; k++)
590                         {
591                                 pResult[i][j] += __pMatrix[i][k] * matrix.__pMatrix[k][j];
592                         }
593                 }
594         }
595
596         for ( int i = 0 ; i < __row ; i++ )
597         {
598                 delete[] __pMatrix[i];
599         }
600
601         delete[] __pMatrix;
602
603         __pMatrix = pResult.release();
604
605         return E_SUCCESS;
606 }
607
608 void
609 IntMatrix::Multiply(int value)
610 {
611         for (int i = 0; i < __row; i++)
612         {
613                 for (int j = 0; j < __column; j++)
614                 {
615                         __pMatrix[i][j] = __pMatrix[i][j] * value;
616                 }
617         }
618 }
619
620 void
621 IntMatrix::Negate(void)
622 {
623         for (int i = 0; i < __row; i++)
624         {
625                 for (int j = 0; j < __column; j++)
626                 {
627                         __pMatrix[i][j] = -__pMatrix[i][j];
628                 }
629         }
630 }
631
632 result
633 IntMatrix::SetAsIdentity(void)
634 {
635         SysTryReturnResult(NID_BASE, __row == __column, E_INVALID_OPERATION, "The current instance is not a square matrix.");
636
637         for (int i = 0; i < __row; i++)
638         {
639                 for (int j = 0; j < __column; j++)
640                 {
641                         if (i == j)
642                         {
643                                 __pMatrix[i][j] = 1;
644                         }
645                         else
646                         {
647                                 __pMatrix[i][j] = 0;
648                         }
649                 }
650         }
651
652         return E_SUCCESS;
653 }
654
655 result
656 IntMatrix::Invert(void)
657 {
658         SysTryReturnResult(NID_BASE, __row == __column, E_INVALID_OPERATION, "The current instance is not a square matrix.");
659
660         int determinant = CalculateDeterminant(__pMatrix, __row);
661         SysTryReturnResult(NID_BASE, determinant != 0, E_INVALID_OPERATION, "The current instance is not invertible.");
662
663         std::unique_ptr<int* []> pInverse(new (std::nothrow) int* [__row]);
664         SysTryReturn(NID_BASE, pInverse != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
665                 GetErrorMessage(E_OUT_OF_MEMORY));
666
667         for (int i = 0; i < __row; i++)
668         {
669                 pInverse[i] = new (std::nothrow) int[__row];
670                 if (pInverse[i] == null)
671                 {
672                         for (int j = 0; j < i;  j++)
673                         {
674                                 delete[] pInverse[j];
675                         }                       
676                         return E_OUT_OF_MEMORY;
677                 }
678         }
679
680         std::unique_ptr<int* []> pMinor(new (std::nothrow) int* [__row - 1]);
681         if (pMinor == null)
682         {
683                 for ( int i = 0 ; i < __row ; i++ )
684                 {
685                         delete[] pInverse[i];
686                 }
687                 return E_OUT_OF_MEMORY;
688         }
689
690         for (int i = 0; i < __row - 1; i++)
691         {
692                 pMinor[i] = new int[__row - 1];
693                 if (pMinor[i] == null)
694                 {
695                         for ( int i = 0 ; i < __row ; i++ )
696                         {
697                                 delete[] pInverse[i];
698                         }
699
700                         for (int j = 0; j < i;  j++)
701                         {
702                                 delete[] pMinor[j];
703                         }
704
705                         return E_OUT_OF_MEMORY;
706                 }
707         }
708
709         for (int i = 0; i < __row; i++)
710         {
711                 for (int j = 0; j < __row; j++)
712                 {
713                         GetMinor(__pMatrix, pMinor.get(), i, j, __row);
714                         pInverse[j][i] = CalculateDeterminant(pMinor.get(), __row - 1) / determinant;
715                         if ((i +j +2) % 2 == 1)
716                         {
717                                 pInverse[j][i] = -pInverse[j][i];
718                         }
719                 }
720         }
721
722         for ( int i = 0 ; i < __row ; i++ )
723         {
724                 delete[] __pMatrix[i];
725         }
726         delete[] __pMatrix;
727
728         __pMatrix = pInverse.release();
729
730         for ( int i = 0 ; i < __row - 1; i++ )
731         {
732                 delete[] pMinor[i];
733         }
734
735         return E_SUCCESS;
736 }
737
738 result
739 IntMatrix::Transpose(void)
740 {
741         SysTryReturnResult(NID_BASE, __row == __column, E_INVALID_OPERATION, "The current instance is not a square matrix.");
742
743         int columnIndex = 1;
744
745         for (int i = 0; i < __row; i++)
746         {
747                 for (int j = 0; j < columnIndex; j++)
748                 {
749                         int temp = __pMatrix[i][j];
750                         __pMatrix[i][j] = __pMatrix[j][i];
751                         __pMatrix[j][i] = temp;
752                 }
753
754                 columnIndex++;
755         }
756
757         return E_SUCCESS;
758 }
759
760 result
761 IntMatrix::SetColumn(int columnIndex, const int* pArray)
762 {
763         SysTryReturnResult(NID_BASE, pArray != null, E_INVALID_ARG, "pArray is null.");
764         SysTryReturnResult(NID_BASE, columnIndex <= __column, E_INVALID_ARG,
765                 "columnIndex is larger than the column count of the current instance.");
766
767         for (int i = 0; i < __row; i++)
768         {
769                 __pMatrix[i][columnIndex] = pArray[i];
770         }
771
772         return E_SUCCESS;
773 }
774
775 result
776 IntMatrix::SetRow(int rowIndex, const int* pArray)
777 {
778         SysTryReturnResult(NID_BASE, pArray != null, E_INVALID_ARG, "pArray is null.");
779         SysTryReturnResult(NID_BASE, rowIndex <= __row, E_INVALID_ARG,
780                 "rowIndex is larger than the row count of the current instance.");
781
782         for (int i = 0; i < __column; i++)
783         {
784                 __pMatrix[rowIndex][i] = pArray[i];
785         }
786
787         return E_SUCCESS;
788 }
789
790 result
791 IntMatrix::SetElement(int rowIndex, int columnIndex, int value)
792 {
793         SysTryReturnResult(NID_BASE, columnIndex <= __column, E_INVALID_ARG,
794                 "columnIndex is larger than the column count of the current instance.");
795         SysTryReturnResult(NID_BASE, rowIndex <= __row, E_INVALID_ARG,
796                 "rowIndex is larger than the row count of the current instance.");
797
798         __pMatrix[rowIndex][columnIndex] = value;
799
800         return E_SUCCESS;
801 }
802
803 result
804 IntMatrix::SetValue(const int* pArray, bool rowMajor)
805 {
806         SysTryReturnResult(NID_BASE, pArray != null, E_INVALID_ARG, "pArray is null.");
807
808         if (rowMajor == true)
809         {
810                 for (int i = 0; i < __row; i++)
811                 {
812                         for (int j = 0; j < __column; j++)
813                         {
814                                 __pMatrix[i][j] = pArray[i * __column + j];
815                         }
816                 }
817         }
818         else
819         {
820                 for (int i = 0; i < __column; i++)
821                 {
822                         for (int j = 0; j < __row; j++)
823                         {
824                                 __pMatrix[j][i] = pArray[i * __row + j];
825                         }
826                 }
827         }
828
829         return E_SUCCESS;
830 }
831
832 void
833 IntMatrix::SetAsNull(void)
834 {
835         for (int i = 0; i < __row; i++)
836         {
837                 for (int j = 0; j < __column; j++)
838                 {
839                         __pMatrix[i][j] = 0;
840                 }
841         }
842 }
843
844 result
845 IntMatrix::Subtract(const IntMatrix& matrix)
846 {
847         SysTryReturnResult(NID_BASE, (__row == matrix.__row) && (__column == matrix.__column), E_INVALID_ARG,
848                 "Either row or column count of the current instance is not same with that of the specified instance.");
849
850         for (int i = 0; i < __row; i++)
851         {
852                 for (int j = 0; j < __column; j++)
853                 {
854                         __pMatrix[i][j] = __pMatrix[i][j] - matrix.__pMatrix[i][j];
855                 }
856         }
857
858         return E_SUCCESS;
859 }
860
861 void
862 IntMatrix::SubtractToEachElement(int value)
863 {
864         for (int i = 0; i < __row; i++)
865         {
866                 for (int j = 0; j < __column; j++)
867                 {
868                         __pMatrix[i][j] = __pMatrix[i][j] - value;
869                 }
870         }
871 }
872
873 }} // Tizen::Base