include/ds/Matrix.h

#ifndef _MATRIX_H_
#define _MATRIX_H_
// ---------------------------------------------
// company   : 
// user      : 
// date      : 22 Mar 2015 17:21
// file      : Matrix.h
// markers   : Full
// language  : C++
// generator : Metamill 6.0
// ---------------------------------------------

//#UBLK-BEG-HEADERH
//==============================================================
// Description : 
//--------------------------------------------------------------
// Author      : Gilberto Luis
// Created     : 16 Dez 2010
//--------------------------------------------------------------
// Change history : 
//   16 Dez 2010 (Gilberto Luis) Initial version generated
//
//==============================================================
//#UBLK-END-HEADERH

/*=================================================================================================
=                                                                                                 =
=       Copyright 2010-2015  Marco Lucio Bittencourt / Fabiano Fernandes Bargos                       =
=                        Gilberto Luis Valente / Jorge Luis Suzuki / Allan Patrick Cordeiro Dias  =
=                                                                                                 =
=       Licensed under the Apache License, Version 2.0 (the "License");                               =
=       you may not use this file except in compliance with the License.                              =
=       You may obtain a copy of the License at                                                       =
=                                                                                                 =
=               http://www.apache.org/licenses/LICENSE-2.0                                                =
=                                                                                                 =
=       Unless required by applicable law or agreed to in writing, software                           =
=       distributed under the License is distributed on an "AS IS" BASIS,                             =
=       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.                      =
=       See the License for the specific language governing permissions and                           =
=       limitations under the License.                                                                =
=                                                                                                 =
=================================================================================================*/


class SymmetricMatrix;


#define SizeAttributesM 24
#define SizeExtraMemM (ALIGNMENT - (SizeAttributesM % ALIGNMENT))


#include <cstdio>
#include "DS_defs.h"
#include "SymmetricMatrix.h"


class Matrix
{
//#UBLK-BEG-CLASSDEF mm:629e3606-c4f4-11df-9da6-88402942916d
//#UBLK-END-CLASSDEF

 public:

   // METHOD=mm:5f0ac0ec-c4f4-11df-9da6-88402942916d
   Matrix();

   // METHOD=mm:5f0ac0ed-c4f4-11df-9da6-88402942916d
   Matrix(unsigned long NumberLines, unsigned long NumberColumns, double InitValue = 0.0);

   // METHOD=mm:5f0ac0ee-c4f4-11df-9da6-88402942916d
   Matrix(Matrix& Instance);

   // METHOD=mm:5f0ac0ef-c4f4-11df-9da6-88402942916d
   Matrix(FILE* File);

   // METHOD=mm:5dfb04f3-dd4f-11e0-9bb1-fbdee659cc27
   ~Matrix();

   // METHOD=mm:5f0ac0f5-c4f4-11df-9da6-88402942916d
   Matrix& operator=(Matrix& Instance);

   // METHOD=mm:5f0ac0f6-c4f4-11df-9da6-88402942916d
   Matrix& Equal(Matrix& Instance);

   // METHOD=mm:5f0ac0f7-c4f4-11df-9da6-88402942916d
   operator double * const();

   // METHOD=mm:5f0ac0f8-c4f4-11df-9da6-88402942916d
   double& operator()(long Row, long Column);

   // METHOD=mm:5f0ac0f9-c4f4-11df-9da6-88402942916d
   double& GetElement(unsigned long Row, unsigned long Column);

   // METHOD=mm:8875f1ab-0dcd-11e0-991f-babcb1a60f9f
   double& GetEndElement();

   // METHOD=mm:c35eea9b-0a05-11e0-8e8f-dbf83d4a9011
   void SetElement(long Row, long Column, double Element);

   // METHOD=mm:5f0ac0fe-c4f4-11df-9da6-88402942916d
   void SetOrder(unsigned long NumberLines = 0, unsigned long NumberColumns = 0, double InitValue = 0.0);

   // METHOD=mm:5f0ac0ff-c4f4-11df-9da6-88402942916d
   void GetOrder(unsigned long& NumberLines, unsigned long& NumberColumns);

   // METHOD=mm:5f0ac100-c4f4-11df-9da6-88402942916d
   long GetNumberLines();

   // METHOD=mm:5f0ac101-c4f4-11df-9da6-88402942916d
   long GetNumberColumns();

   // METHOD=mm:5f0ac102-c4f4-11df-9da6-88402942916d
   unsigned long GetNumberElements();

   // METHOD=mm:5f0ac103-c4f4-11df-9da6-88402942916d
   long SizeOf();

   // METHOD=mm:5f0ac108-c4f4-11df-9da6-88402942916d
   void Reset(double Value = 0.0);

   // METHOD=mm:5f0ac109-c4f4-11df-9da6-88402942916d
   void Identity();

   // METHOD=mm:5f0ac10a-c4f4-11df-9da6-88402942916d
   void Transpose(Matrix& Transpost);

   // METHOD=mm:5f0ac10b-c4f4-11df-9da6-88402942916d
   void Insert(Matrix& SubMatrix, long InitLine = 0, long InitColumn = 0);

   // METHOD=mm:5f0ac10c-c4f4-11df-9da6-88402942916d
   double Maximum();

   // METHOD=mm:5f0ac10d-c4f4-11df-9da6-88402942916d
   double Minimum();

   // METHOD=mm:5f0ac112-c4f4-11df-9da6-88402942916d
   double EuclideanNorm();

   // METHOD=mm:5b4516c3-b4a4-11e0-948c-88b1406d0184
   Matrix& Product(double* A, unsigned long N, double b = 1.0);

   // METHOD=mm:5f0ac113-c4f4-11df-9da6-88402942916d
   double Norm1();

   // METHOD=mm:5f0ac114-c4f4-11df-9da6-88402942916d
   double NormInfinity();

   // METHOD=mm:5f0ac115-c4f4-11df-9da6-88402942916d
   Matrix& Chs();

   // METHOD=mm:5f0ac116-c4f4-11df-9da6-88402942916d
   Matrix& operator-();

   // METHOD=mm:5f0ac117-c4f4-11df-9da6-88402942916d
   Matrix& Add(Matrix& A, Matrix& B);

   // METHOD=mm:5f0ac11c-c4f4-11df-9da6-88402942916d
   friend Matrix operator+(Matrix& A, Matrix& B);

   // METHOD=mm:5f0ac11d-c4f4-11df-9da6-88402942916d
   Matrix& operator+=(Matrix& B);

   // METHOD=mm:5f0ac11e-c4f4-11df-9da6-88402942916d
   Matrix& Add(Matrix& B);

   // METHOD=mm:5f0ac11f-c4f4-11df-9da6-88402942916d
   Matrix& Subtract(Matrix& A, Matrix& B);

   // METHOD=mm:5f0ac120-c4f4-11df-9da6-88402942916d
   friend Matrix operator-(Matrix& A, Matrix& B);

   // METHOD=mm:5f0ac121-c4f4-11df-9da6-88402942916d
   Matrix& operator-=(Matrix& B);

   // METHOD=mm:5f0ac126-c4f4-11df-9da6-88402942916d
   Matrix& Subtract(Matrix& B);

   // METHOD=mm:5f0ac127-c4f4-11df-9da6-88402942916d
   Matrix& Add(double Scalar);

   // METHOD=mm:5f0ac128-c4f4-11df-9da6-88402942916d
   Matrix& operator+=(double Scalar);

   // METHOD=mm:5f0ac129-c4f4-11df-9da6-88402942916d
   Matrix& Subtract(double Scalar);

   // METHOD=mm:5f0ac12a-c4f4-11df-9da6-88402942916d
   Matrix& operator-=(double Scalar);

   // METHOD=mm:5f0ac12b-c4f4-11df-9da6-88402942916d
   Matrix& Multiplicate(double Scalar);

   // METHOD=mm:5f0ac130-c4f4-11df-9da6-88402942916d
   Matrix& operator*=(double Scalar);

   // METHOD=mm:5f0ac131-c4f4-11df-9da6-88402942916d
   double ScalarProduct(Matrix& B);

   // METHOD=mm:f53fb377-0d39-11e0-960e-85a0a6aeef2e
   void TensorProduct(Matrix& A, Matrix& B);

   // METHOD=mm:5f0ac132-c4f4-11df-9da6-88402942916d
   double operator^(Matrix& B);

   // METHOD=mm:5f0ac133-c4f4-11df-9da6-88402942916d
   friend Matrix operator*(Matrix& A, Matrix& B);

   // METHOD=mm:5f0ac134-c4f4-11df-9da6-88402942916d
   Matrix& Multiplicate(Matrix& A, Matrix& B);

   // METHOD=mm:5f0ac135-c4f4-11df-9da6-88402942916d
   friend Matrix operator*(Matrix& A, SymmetricMatrix& B);

   // METHOD=mm:5f0ac13a-c4f4-11df-9da6-88402942916d
   Matrix& Multiplicate(Matrix& A, SymmetricMatrix& B);

   // METHOD=mm:5f0ac13b-c4f4-11df-9da6-88402942916d
   friend Matrix operator*(SymmetricMatrix& A, Matrix& B);

   // METHOD=mm:5f0ac13c-c4f4-11df-9da6-88402942916d
   Matrix& Multiplicate(SymmetricMatrix& A, Matrix& B);

   // METHOD=mm:5f0ac13d-c4f4-11df-9da6-88402942916d
   friend Matrix operator*(SymmetricMatrix& A, SymmetricMatrix& B);

   // METHOD=mm:5f0ac13e-c4f4-11df-9da6-88402942916d
   Matrix& Multiplicate(SymmetricMatrix& A, SymmetricMatrix& B);

   // METHOD=mm:5f0ac13f-c4f4-11df-9da6-88402942916d
   Matrix& TripleProduct(Matrix& A, Matrix& B);

   // METHOD=mm:5f0ac144-c4f4-11df-9da6-88402942916d
   void Save(FILE* File);

   // METHOD=mm:5f0ac145-c4f4-11df-9da6-88402942916d
   void Save(char* TabName, int Version, char* Filename);

   // METHOD=mm:5f0ac146-c4f4-11df-9da6-88402942916d
   void Restore(FILE* File);

   // METHOD=mm:5f0ac147-c4f4-11df-9da6-88402942916d
   void Restore(char* TabName, int Version, char* Filename);

   // METHOD=mm:5f0ac148-c4f4-11df-9da6-88402942916d
   void Print(FILE* File, char* Title, char* Format);

   // METHOD=mm:5f0ac149-c4f4-11df-9da6-88402942916d
   void Print(FILE* File = stdout, const char* Message = "", int NumMaxCols = 5, int Mant = 14, int Dec = 7);

   // METHOD=mm:5f0ac14e-c4f4-11df-9da6-88402942916d
   void Free();

   // METHOD=mm:5f0ac14f-c4f4-11df-9da6-88402942916d
   void GaussSolver(double* U, double* B, double Precision);

   // METHOD=mm:5f0ac150-c4f4-11df-9da6-88402942916d
   void GaussSolver();

   // METHOD=mm:5f0ac151-c4f4-11df-9da6-88402942916d
   void GaussSolver(double* U, double* B);

   // METHOD=mm:5f0ac152-c4f4-11df-9da6-88402942916d
   void GaussSeidel(double* U, double* B, long MaxNumberIter, double Omega, double Precision = 1.0e-4, double RelaxFactor = 1.81, NormDS_E Norm = EUCLID);


 protected:

   // METHOD=mm:5f0ac153-c4f4-11df-9da6-88402942916d
   void Alloc(double InitValue = 0.0);

   // METHOD=mm:5f0ac158-c4f4-11df-9da6-88402942916d
   friend inline void Multiplicate(Matrix& A, SymmetricMatrix& B, Matrix& C);

   // METHOD=mm:b3511349-d561-43ea-9a3e-172a7c405aed
   double scalv(double* x, double* y, unsigned long dim);

   // METHOD=mm:96d04aca-6c60-4347-9216-2053a2f07022
   int mitgsl(double* vetx, double* ma, double* vetb, long neq, long itmax, double eps, double beta, int codconvg);

   // METHOD=mm:ed2b7a2d-0610-473d-9551-8f966b75cb6d
   void prmatba(double* ma, double* mb, long nlina, long ncola, double* mc);

   // METHOD=mm:335c6dda-d9f1-4c81-b52b-b43b1276e0eb
   int mgausst1(double* ma, unsigned long neq, long* step, long* vinfopiv, double* auxptr);

   // METHOD=mm:2351935c-5016-4e7c-9d03-67e9e63e21a0
   void solgauss1(double* vetx, double* ma, double* vetb, long neq, long* vinfopiv);


   // attr=mm:5f0ac0e4-c4f4-11df-9da6-88402942916d
   int GaussFlag;

   // attr=mm:5f0ac0e1-c4f4-11df-9da6-88402942916d
   unsigned long NumLines;

   // attr=mm:5f0ac0e2-c4f4-11df-9da6-88402942916d
   unsigned long NumColumns;

   // attr=mm:5f0ac0e5-c4f4-11df-9da6-88402942916d
   long* VInfoPiv;

   // attr=mm:5f0ac0e3-c4f4-11df-9da6-88402942916d
   double* FMatrix;

   // attr=mm:5f0ac0ea-c4f4-11df-9da6-88402942916d
   double* AuxPtr;

   // attr=mm:fd20ebc9-344e-11e0-8e77-a21ed083ce8a
   char ExtraMemory[SizeExtraMemM];


 private:

//#UBLK-BEG-CLASSMEMB mm:629e3606-c4f4-11df-9da6-88402942916d
//#UBLK-END-CLASSMEMB
};

//#UBLK-BEG-GLOBALH
//*** Removed methods: 21 Dez 2010 17:42
//---
//uuid=mm:bc232d41-0c3f-11e0-9f76-cabf8e30fede
//   double& GetEndElement();

//*** Removed methods: 21 Fev 2011 17:44
//---
//uuid=mm:e6f59b69-3841-11e0-893c-fc4410c867b1
//   long SizeOfAttributes();

//*** Removed methods: 23 Jul 2011 12:15
//---
//uuid=mm:0acdc113-b4a4-11e0-948c-88b1406d0184
//   Matrix& TransposeProduct(Matrix& A);

//#UBLK-END-GLOBALH


#endif // _MATRIX_H_