C умножение матриц – умножение матриц | C++ для приматов

alexxlab / / Школьная жизнь

умножение матриц | C++ для приматов

import java.util.*;

import java.lang.*;

import java.io.*;

 

class Ideone {

    public static void main (String[] args) throws java.lang.Exception {

        Scanner read = new Scanner (System.in);

        int n = read.nextInt();                                         //ввод из стандартного потока

        double A[][] = new double [n][n];                                      

        double B[][] = new double [n][n];

        double Z[][] = new double [n][n];

        double H[][] = new double [n][n];

        double E[][] = new double [n][n];

        double C[][] = new double [n][n];

        double Ans[][] = new double [n][n];

    

        for (int i = 0; i < n; i++){             //матрица А

            for (int j = 0 ; j < n ; j++){

                A[i][j] = read.nextDouble();

            }

        }

    

        for (int i = 0; i < n; i++){                            //матрица В

            for (int j = 0 ; j < n ; j++){

                B[i][j] =  read.nextDouble();

            }

        }

    

        for (int i = 0; i < n; i++){                            //единичная матрица Е

            for (int j = 0 ; j < n ; j++){

                if (i == j) E[i][j] = 1;

                else E[i][j] = 0;

            }

        }

    

        for (int i = 0; i < n; i++){                 //разность матриц В и Е

            for (int j = 0; j < n; j++){

                Z[i][j] = 0;

                Z[i][j] = B[i][j] — E[i][j];

            }

        }

        

        for (int i = 0; i < n; i++){             //умножение матриц А и (В — Е)

            for (int j = 0; j < n; j++){

                H[i][j] = 0;

                for (int t = 0; t < n; t++){

                    H[i][j] += A[i][t] * Z[t][j];

                }

            }

        }

        

        for (int i = 0; i < n; i++){             //матрица С

            for (int j = 0; j < n; j++){

                C[i][j] = 0;

                C[i][j] = 1.0/((i+1)+(j+1));

            }

        }

        

        for (int i = 0; i < n; i++){                 //матрица A(B–E)+C

            for(int j = 0; j < n; j++){

                Ans[i][j] = H[i][j] + C[i][j];

                System.out.print(Ans[i][j] + » «);

            }

            System.out.println();

        }

    }

}

cpp.mazurok.com

C#: Класс «Матрица» (сложение, вычитание, умножение матриц)

 Данный класс позволяет производить некоторые операции над матрицами:

  1. Сложение матрицы А с матрицой Б
  2. Вычитание матрицы Б из матрицы А
  3. Умножение матрицы А на матрицу Б
  4. Умножение матрица А на число
  5.  Проверка матрицы А на единичность
  6. Выполнение нексольких операций над матрицами одновременно, образуя матрицу D 

Так же он содержит операторы перегрузки и скрытые поля для соблудения инкапсуляции.

 Язык программирования С#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Matrix
    {
        // Скрытые поля
        private int n;
        private int[,] mass;

        // Создаем конструкторы матрицы
        public Matrix() { }
        public int N
        {
            get { return n; }
            set { if(value>0) n = value; }
        }

        // Задаем аксессоры для работы с полями вне класса Matrix
        public Matrix(int n)
        {
            this.n = n;
            mass = new int[this.n, this.n];
        }
        public int this [int i, int j]
        {
            get
            {
                return mass[i, j];
            }
            set
            {
                mass[i, j] = value;
            }
        }

        // Ввод матрицы с клавиатуры
        public void WriteMat()
        {
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.WriteLine("Введите элемент матрицы {0}:{1}", i+1, j+1);
                    mass[i, j] = Convert.ToInt32(Console.ReadLine());
                }
            }
        }

        // Вывод матрицы с клавиатуры
        public void ReadMat()
        {
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    Console.Write(mass[i, j] + "\t");


                }
                Console.WriteLine();
            }
        }

        // Проверка матрицы А на единичность
        public void oneMat(Matrix a){
            int count = 0;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (a[i, j] == 1 && i == j)
                    {
                        count++;
                    }
                }

            }
            if (count == a.N)
            {
                Console.WriteLine("Единичная");
            }
            else Console.WriteLine("Не единичная");


        }

        // Умножение матрицы А на число
        public static Matrix umnch(Matrix a, int ch)
        {
            Matrix resMass = new Matrix(a.N);
            for (int i = 0; i < a.N; i++)
            {
                for (int j = 0; j < a.N; j++)
                {
                    resMass[i, j] = a[i, j] * ch;
                }
            }
            return resMass;
        }

        // Умножение матрицы А на матрицу Б
        public static Matrix umn(Matrix a, Matrix b)
        {
            Matrix resMass = new Matrix(a.N);
            for (int i = 0; i < a.N; i++)


                for (int j = 0; j < b.N; j++)
                    for (int k = 0; k < b.N; k++)
                        resMass[i, j] += a[i, k]*b[k, j];

            return resMass;
        }

        // перегрузка оператора умножения
        public static Matrix operator *(Matrix a, Matrix b)
        {
            return Matrix.umn(a, b);
        }

        public static Matrix operator *(Matrix a, int b)
        {
            return Matrix.umnch(a, b);
        }

        // Метод вычитания матрицы Б из матрицы А
        public static Matrix razn(Matrix a, Matrix b)
        {
            Matrix resMass = new Matrix(a.N);
            for (int i = 0; i < a.N; i++)


            {
                for (int j = 0; j < b.N; j++)
                {
                    resMass[i, j] = a[i, j] - b[i, j];
                }
            }
            return resMass;
        }

        // Перегрузка оператора вычитания
        public static Matrix operator -(Matrix a, Matrix b)
        {
            return Matrix.razn(a, b);
        }
        public static Matrix Sum(Matrix a, Matrix b)
        {
            Matrix resMass = new Matrix(a.N);
            for (int i = 0; i < a.N; i++ )
            {
                for(int j = 0; j < b.N; j++)
                {

                    resMass[i, j] = a[i, j] + b[i, j];
                }
            }
            return resMass;
        }
        // Перегрузка сложения
        public static Matrix operator +(Matrix a, Matrix b)
        {
            return Matrix.Sum(a, b);
        }
        // Деструктор Matrix
        ~Matrix()
        {
            Console.WriteLine("Очистка");
        }

    }
    class MainProgram{

        static void Main(string[] args)
        {
            Console.WriteLine ("Введите размерность матрицы: ");
            int nn = Convert.ToInt32 (Console.ReadLine ());
            // Инициализация


            Matrix mass1 = new Matrix(nn);
            Matrix mass2 = new Matrix(nn);
            Matrix mass3 = new Matrix(nn);
            Matrix mass4 = new Matrix(nn);
            Matrix mass5 = new Matrix(nn);
            Matrix mass6 = new Matrix(nn);
            Matrix mass7 = new Matrix(nn);
            Matrix mass8 = new Matrix(nn);
            Console.WriteLine("ввод Матрица А: ");
            mass1.WriteMat();
            Console.WriteLine("Ввод Матрица B: ");
            mass2.WriteMat();

            Console.WriteLine("Матрица А: ");
            mass1.ReadMat();
            Console.WriteLine();
            Console.WriteLine("Матрица В: ");
            Console.WriteLine();


            mass2.ReadMat();

            Console.WriteLine ("Сложение матриц А и Б: ");
            mass4 = (mass1 + mass2);
            mass4.ReadMat ();

            Console.WriteLine ("Вычитание матриц А и Б: ");
            mass6 = (mass1 - mass2);
            mass6.ReadMat ();

            Console.WriteLine ("Умножение матриц А и Б: ");
            mass8 = (mass1 * mass2);
            mass8.ReadMat ();

            Console.WriteLine ("Умножение матрицы А на число 2: ");
            mass5 = (mass1 * 2);
            mass5.ReadMat ();

            Console.WriteLine ("Матрица D по формуле  D=3AB+(A-B)A: ");
            mass7 = ( (mass1 * 3) * mass2 + (mass1-mass2) * mass1);
            mass7.ReadMat ();

            Console.ReadKey();
        }
    }
}


Please enable JavaScript to view the comments powered by Disqus.

tumovsky.by

Блочное умножение матриц для программистов — Блог Евгения Жирнова

#include <stdio.h>
#include <string.h>
 
 
void Rec_Mult(int *C, const int *A, const int *B, int n, int rowsize)
{
    if (n == 2)
    {
        const int d11 = 0;
        const int d12 = 1;
        const int d21 = rowsize;
        const int d22 = rowsize + 1;
 
        C[d11] += A[d11] * B[d11] + A[d12] * B[d21];
        C[d12] += A[d11] * B[d12] + A[d12] * B[d22];
        C[d21] += A[d21] * B[d11] + A[d22] * B[d21];
        C[d22] += A[d21] * B[d12] + A[d22] * B[d22];
    }
    else
    {
        const int d11 = 0;
        const int d12 = n / 2;
        const int d21 = (n / 2) * rowsize;
        const int d22 = (n / 2) * (rowsize + 1);
 
        // C11 += A11 * B11
        Rec_Mult(C + d11, A + d11, B + d11, n / 2, rowsize);
        // C11 += A12 * B21
        Rec_Mult(C + d11, A + d12, B + d21, n / 2, rowsize);
 
        // C12 += A11 * B12
        Rec_Mult(C + d12, A + d11, B + d12, n / 2, rowsize);
        // C12 += A12 * B22
        Rec_Mult(C + d12, A + d12, B + d22, n / 2, rowsize);
 
        // C21 += A21 * B11
        Rec_Mult(C + d21, A + d21, B + d11, n / 2, rowsize);
        // C21 += A22 * B21
        Rec_Mult(C + d21, A + d22, B + d21, n / 2, rowsize);
 
        // C22 += A21 * B12
        Rec_Mult(C + d22, A + d21, B + d12, n / 2, rowsize);
        // C22 += A22 * B22
        Rec_Mult(C + d22, A + d22, B + d22, n / 2, rowsize);
    }
}
 
 
#define ROW_COUNT 8
 
 
void printMatrix(const char *name, const int *mat)
{
    printf("%s:\n", name);
 
    for (int i = 0; i < ROW_COUNT; ++i)
    {
        for (int j = 0; j < ROW_COUNT; ++j)
        {
            printf("%4d", mat[i * ROW_COUNT + j]);
        }
        printf("\n");
    }
    printf("\n");
}
 
 
int main()
{
    const int matA[ROW_COUNT * ROW_COUNT] =
    {
        1, 2, 3, 0, 0, 4, 5, 6,
        1, 2, 3, 0, 0, 4, 5, 6,
        1, 2, 3, 0, 0, 4, 5, 6,
        1, 2, 3, 0, 0, 4, 5,

blog2k.ru

No related posts.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *