Programacion C++ Java C#

En matemáticas, la multiplicación o producto de matrices es la operación de composición efectuada entre dos matrices, o bien la multiplicación entre una matriz y un escalar según unas reglas.
Al igual que la multiplicación aritmética, su definición es instrumental, es decir, viene dada por un algoritmo capaz de efectuarla. El algoritmo para la multiplicación matricial es diferente del que resuelve la multiplicación de dos números. La diferencia principal es que la multiplicación de matrices no cumple con la propiedad de conmutatividad.

La multiplicación de matrices es muy útil para la resolución de sistemas de ecuaciones de muchas variables, dado que son muy cómodas para ser implementadas mediante un computador. El cálculo numérico se basa en gran parte de estas operaciones, al igual que poderosas aplicaciones tales como MATLAB. También actualmente se utiliza mucho en el cálculo de microarrays, en el área de bioinformática.

En este ejemplo se utilizan dos matrices estáticas con valores en sus casillas, lo importante de esto es la función que sirve para multiplicarlas, en el ejemplo del programa se especifica el limite de las casillas, que en este caso e 3, al final solo se imprime el resultado para comparar que los cálculos fueron correctos.

#include <iostream>
#define limite 3
using std::cout;
using std::cin;
static int matriz1[limite][limite] = {{3,4,7},
                                     {8,10,12},
                                     {3,4,5}};
                                     
static int matriz2[limite][limite] = {{25,7,9},
                                     {24,32,12},
                                     {15,32,24}};
                                     
void imprimirMatriz(int matriz[limite][limite]){
     for(int i = 0; i < limite; i++){
        cout << "\t";  
        for(int e = 0; e < limite; ++e)
            cout << matriz[i][e] << " ";
        cout << "\n";
    }
}
void multiplicarMatrices(int MatrizResultado[limite][limite]){
    for(int j = 0; j < limite; j++){
        for(int i = 0; i < limite; i++){
            MatrizResultado[j][i] = 0;
            for(int e = 0; e < limite; ++e){        
                MatrizResultado[j][i] += matriz1[j][e] * matriz2[e][i];
            }
        }                
    }
}
int main(){    
    int MatrizResultado[limite][limite];    
    cout << "\t\tMultiplicacion de Matrices\n";
    cout << "\t________________________________________\n\n";
    cout << "matriz 1 : \n"; 
    imprimirMatriz(matriz1);
    cout << "\n\n";
    cout << "matriz 2 : \n";
    imprimirMatriz(matriz2);
    multiplicarMatrices(MatrizResultado);
    cout << "\nResultado: \n";
    imprimirMatriz(MatrizResultado);    
    cin.get();  
    return 0;  
}

Los números complejos son una extensión de los números reales y forman el mínimo cuerpo algebraicamente cerrado que los contiene. El conjunto de los números complejos se designa como , siendo el conjunto de los reales se cumple que . Los números complejos incluyen todas las raíces de los polinomios, a diferencia de los reales. Todo número complejo puede representarse como la suma de un número real y un número imaginario (que es un múltiplo real de la unidad imaginaria, que se indica con la letra i).

Los números complejos son la herramienta de trabajo del álgebra ordinaria, llamada álgebra de los números complejos, así como de ramas de las matemáticas puras y aplicadas como variable compleja, aerodinámica y electromagnetismo entre otras de gran importancia. Además los números complejos se utilizan por doquier en matemáticas, en muchos campos de la física (notoriamente en la mecánica cuántica) y en ingeniería, especialmente en la electrónica y las telecomunicaciones, por su utilidad para representar las ondas electromagnéticas y la corriente eléctrica.
En matemáticas, los números constituyen un cuerpo y, en general, se consideran como puntos del plano: el plano complejo. La propiedad más importante que caracteriza a los números complejos es el teorema fundamental del álgebra, que afirma que cualquier ecuación algebraica de grado n tiene exactamente n soluciones complejas. Contienen a los números reales y los imaginarios puros y constituyen una de las construcciones teóricas más importantes de la inteligencia humana. Los análogos del cálculo diferencial e integral con números complejos reciben el nombre de variable compleja o análisis complejo.

En este programa se muestra un ejemplo de una calculadora simple manejando números complejos en una clase llamada Complejo y su respectiva clase Main donde se muestra un ejemplo de como utilizarla. Las operaciones básicas en este programa son:

Suma

$(a, b) + (c, d) = (a+c,\, b+d)$

Resta

$(a, b) - (c, d) = (a-c,\, b-d)$

Multiplicación

$(a, b) \cdot (c, d) = (ac - bd, ad + bc)$

División

$\frac{(a, b)}{(c, d)} = {(ac+bd,\,bc-ad) \over c^2+d^2} = \left({ac + bd \over c^2 + d^2} , {bc - ad \over c^2 + d^2}\right)$

public class Complejo{
    private double real;
    private double imaginario;
    public Complejo (){
        real = 0.0;
        imaginario = 0.0;
    }
    public Complejo (double real, double im){
        this.real = real;
        imaginario = im;
    }    
    public void getComplejo(double r, double i){
        real = r;
        imaginario = i;
    }    
    public void setReal(double numeroReal){
        real = numeroReal;
    }    
    public void setImaginario(double numeroImaginario){
        imaginario = numeroImaginario;
    }    
    public double getReal(){
        return real;
    }    
    public double getImaginario(){
        return imaginario;
    }    
    public Complejo suma(Complejo sumando){
        Complejo resultado;
        resultado = new Complejo();         
        resultado.setReal(this.real + sumando.getReal() );         
        resultado.setImaginario(this.imaginario + sumando.getImaginario());      
        return resultado;
    }    
    public Complejo resta (Complejo resta){
        Complejo resultado;
        resultado = new Complejo();         
        resultado.setReal(this.real - resta.getReal() );         
        resultado.setImaginario(this.imaginario - resta.getImaginario());         
        return resultado;
    }    
    public Complejo multiplicacion (Complejo producto){
        Complejo resultado;
        resultado = new Complejo();         
        resultado.getComplejo(((this.real * producto.getReal())-

            (this.imaginario * producto.getImaginario())),
            ((this.real * producto.getImaginario() ) +

            (this.imaginario * producto.getReal() )));
        return resultado;
    }
    public Complejo division(Complejo divisor){
        Complejo resultado;
        resultado = new Complejo();         
        resultado.getComplejo((((this.real * divisor.getReal()) +

            (this.imaginario * divisor.getImaginario()))/
            ((divisor.getReal() * divisor.getReal())+

            (divisor.getImaginario() * divisor.getImaginario()))),
            (((this.real * divisor.getImaginario() ) -

            (this.imaginario * divisor.getReal() ))/((divisor.getReal() * 
            divisor.getReal())+(divisor.getImaginario() *

            divisor.getImaginario()))));
        return resultado;
    }    
}

Después se muestra un ejemplo de como utilizar estas operaciones en la clase Main

import java.util.*;
public class Main{
    private static Scanner teclado = new Scanner (System.in);
    public static int Menu(){
        int opcion;
        System.out.println();
        System.out.println("calculadora de numeros complejos");
        System.out.println();
        System.out.println("1)SUMAR");
        System.out.println("2)RESTAR");
        System.out.println("3)MULTIPLICAR");
        System.out.println("4)DIVIDIR");
        System.out.println("5)SALIR");
        System.out.println();
        System.out.print(" OPCION: ");
        opcion = teclado.nextInt();
        return opcion;
    }
    public static void main(String args[]){        
        Complejo calculadora,complejo1,complejo2,resultado;
        Process p;
        calculadora = new Complejo();
        double real, imag;
        int opcion;
        do{
            opcion = Menu();
            
            switch(opcion){
                case 1: 
                    System.out.print("Escribe el primer real: ");
                    real = teclado.nextDouble();
                    System.out.print("Escribe el primer imaginario: ");
                    imag = teclado.nextDouble();                    
                    complejo1 = new Complejo (real, imag);    
                    System.out.print("Escribe el segundo real: ");
                    real = teclado.nextDouble();
                    System.out.print("Escribe el segundo imaginario: ");
                    imag = teclado.nextDouble();                    
                    complejo2 = new Complejo (real, imag);                    
                    resultado = complejo1.suma(complejo2);
                    if (resultado.getImaginario() < 0.0)
                      System.out.println("El resultadoultado es: " + 
                      resultado.getReal() +"+ i"+ -resultado.getImaginario());
                    else
                       System.out.println("El resultadoultado es: " + 
                       resultado.getReal() +"+ i"+ resultado.getImaginario());
                    break;
                case 2:
                    System.out.print("Escribe el primer real: ");
                    real = teclado.nextDouble();
                    System.out.print("Escribe el primer imaginario: ");
                    imag = teclado.nextDouble();    
                    complejo1 = new Complejo (real, imag);    
                    System.out.print("Escribe el segundo real: ");
                    real = teclado.nextDouble();
                    System.out.print("Escribe el segundo imaginario: ");
                    imag = teclado.nextDouble();
                    complejo2 = new Complejo (real, imag);
                    resultado = complejo1.resta(complejo2);                    
                    if (resultado.getImaginario() <0.0)
                      System.out.println("El resultadoultado es: " + 
                      resultado.getReal() +"+ i"+ -resultado.getImaginario());
                    else
                      System.out.println("El resultadoultado es: " + 
                      resultado.getReal() +"+ i"+ resultado.getImaginario());
                    break;
                case 3:
                    System.out.print("Escribe el primer real: ");
                    real = teclado.nextDouble();
                    System.out.print("Escribe el primer imaginario: ");
                    imag = teclado.nextDouble();    
                    complejo1 = new Complejo (real, imag);    
                    System.out.print("Escribe el segundo real: ");
                    real = teclado.nextDouble();
                    System.out.print("Escribe el segundo imaginario: ");
                    imag = teclado.nextDouble();
                    complejo2 = new Complejo (real, imag);
                    resultado = complejo1.resta(complejo2);
                    resultado = complejo1.multiplicacion(complejo2);
                    if (resultado.getImaginario() <0.0)
                      System.out.println("El resultadoultado es: " + 
                      resultado.getReal() +"+ i"+ -resultado.getImaginario());
                    else
                      System.out.println("El resultadoultado es: " + 
                      resultado.getReal() +"+ i"+ resultado.getImaginario());
                    break;
                case 4:
                    System.out.print("Escribe el primer real: ");
                    real = teclado.nextDouble();
                    System.out.print("Escribe el primer imaginario: ");
                    imag = teclado.nextDouble();    
                    complejo1 = new Complejo (real, imag);    
                    System.out.print("Escribe el segundo real: ");
                    real = teclado.nextDouble();
                    System.out.print("Escribe el segundo imaginario: ");
                    imag = teclado.nextDouble();
                    complejo2 = new Complejo (real, imag);
                    resultado = complejo1.resta(complejo2);
                    resultado = complejo1.division(complejo2);
                    if (resultado.getImaginario() <0.0)
                      System.out.println("El resultadoultado es: "+ 
                      resultado.getReal() +"+ i"+ -resultado.getImaginario());
                    else
                      System.out.println("El resultadoultado es: " + 
                      resultado.getReal() +"+ i"+ resultado.getImaginario());
                    break;
                case 5:
                    System.out.println("adios");
                    break;
                default: 
                    break;
            }
        }while(opcion!=5);
    }
}

Páginas

NIMADRES

Multiplicación de matrices en C++

Números complejos en java

Seguidores

Contador

Redes Sociales

Sigueme en twiter

Datos personales

Enlaces Externos

Nosferatu