example_matrix_operators_binary.cpp

Programa para el testeo de las funciones.

Programa para el testeo de las funciones.Para compilar o código example_matrix_operators_binary.cpp:

g++ -static -o example_matrix_operators_binary example_matrix_operators_binary.cpp -lpdsramm 

Para executar o programa:

./example_matrix_operators_binary

Retornando por consola:

A:
0       1
1       1
B:
0       1
1       1
V:
1
1
D:
1       1       1
1       0       0
1       1       1

A.Add(B)
 0 2
 2 2
A+B
 0 2
 2 2
2-A+5
 7 6
 6 6

A.Mul(B)
 1 1
 1 2
A.Mul(B,C)
 1 1
 1 2
A.Mul(V)
 1
 2
================================================================
F:
0       1       1
1       0       1
1       1       1
0       1       1
G:
0       0
1       0
1       1
0       1
F.T()
 0 1 1 0
 1 0 1 1
 1 1 1 1
F.TMul(G)
 2 1
 1 2
 2 2
F.T()*G
 2 1
 1 2
 2 2
================================================================
A*B
 1 1
 1 2

A.Div(2)
   0 0.5
 0.5 0.5
A/2
   0 0.5
 0.5 0.5

C
  0  4  8 12
  1  5  9 13
  2  6 10 14
  3  7 11 15

C.Geq(8)
 0 0 1 1
 0 0 1 1
 0 0 1 1
 0 0 1 1

C.Leq(8)
 1 1 1 0
 1 1 0 0
 1 1 0 0
 1 1 0 0

A
 0 1
 1 1
B1
 3 3
A.AddRowMatrix(B1)
 3 4
 4 4
A.SubRowMatrix(B1)
 -3 -2
 -2 -2


A
 0 1
 1 1
B
 0 1
 1 1
B.Product(A.Product(B))
 0 1
 1 1
B&A&B
 0 1
 1 1
A.Division(B)
 -nan    1
    1    1
A/B
 -nan    1
    1    1
A.Pow(B)
 1 1
 1 1

Código example_matrix_operators_binary.cpp:

 
#include <iostream>
#include <Pds/Ra>
    
int main(void)
{
    Pds::Matrix A(2,2);
    Pds::Matrix B(2,2);
    Pds::Matrix B1(1,2,3);
    Pds::Matrix C;
    Pds::Vector V(2);
    Pds::Matrix D(3,3);
 
    
    A.FillRandC(0.8);    std::cout<<"A:\n"<<A;
    B.FillRandC(0.8);    std::cout<<"B:\n"<<B;
    V.FillRandC(0.8);    std::cout<<"V:\n"<<V;
    D.FillRandC(0.8);    std::cout<<"D:\n"<<D;    
    
    // + operator
    std::cout<<std::endl;
    
    C=A.Add(B);
    C.Print("A.Add(B)\n");
    
    C=A+B;
    C.Print("A+B\n");
    
    C=2-A+5;
    C.Print("2-A+5\n");
    
    // * operator
    std::cout<<std::endl;
    
    C=A.Mul(B);
    C.Print("A.Mul(B)\n");
    
    C.Fill(0.0);
    A.Mul(B,C);
    C.Print("A.Mul(B,C)\n");
    
    C=A.Mul(V);
    C.Print("A.Mul(V)\n");
 
    std::cout<<Pds::Ra::Repeat("=",64)<<"\n";
    
    Pds::Matrix F(4,3); F.FillRandC(0.6); std::cout<<"F:\n"<<F;
    Pds::Matrix G(4,2); G.FillRandC(0.6); std::cout<<"G:\n"<<G;
    
    F.T().Print("F.T()\n");
    
    C=F.TMul(G);
    C.Print("F.TMul(G)\n");
    
    C=F.T()*G;
    C.Print("F.T()*G\n");
    
    std::cout<<Pds::Ra::Repeat("=",64)<<"\n";
        
    C=A*B;
    C.Print("A*B\n");
    
    // / operator
    std::cout<<std::endl;
    
    C=A.Div(2);
    C.Print("A.Div(2)\n");
    
    C=A/2;
    C.Print("A/2\n");
    
    // Geq y Leq
    C=Pds::MatrixId(4,4);
    C.Print("\nC\n");
 
    C.Geq(8).Print("\nC.Geq(8)\n");
 
    C.Leq(8).Print("\nC.Leq(8)\n");
 
    A.Print("\nA\n");
    B1.Print("B1\n");
 
    C=A.AddRowMatrix(B1);
    C.Print("A.AddRowMatrix(B1)\n");
 
    C=A.SubRowMatrix(B1);
    C.Print("A.SubRowMatrix(B1)\n");
    
    // (*) operator
    std::cout<<std::endl;
    
    A.Print("\nA\n");
    B.Print("B\n");
    
    C=B.Product(A.Product(B));
    C.Print("B.Product(A.Product(B))\n");
        
    C=B&A&B;
    C.Print("B&A&B\n");
    
    C=A.Div(B);
    C.Print("A.Division(B)\n");
        
    C=A/B;
    C.Print("A/B\n");
   
    C=A.Pow(B);
    C.Print("A.Pow(B)\n");
        
    return 0;
}