Вещественная Матрица

Тема в разделе "MS Visual C++", создана пользователем 250391, 27 фев 2012.

  1. 250391

    250391 Гость

    Не могу найти готовый листинг задания на Visual C++. На С# есть, а на С++ нет. Поделитесь у кого есть, пожалуйста.
    Описать класс, реализующий тип данных «вещественная матрица» и работу с ними. Класс должен реализовывать следующие операции над матрицами:
    а) сложение, вычитание, умножение, деление (+, -, *, /) (умножение и
    деление, как на другую матрицу, так и на число);
    б) комбинированные операции присваивания (+=, -=, *=, /=);
    в) операции сравнения на равенство/неравенство;
    г) операции ввода/вывода в стандартные потоки.
     
  2. qqwertty

    qqwertty Гость

    по кускам найти можно, я основную часть нашел, почти первая ссылка в гугле
     
  3. 250391

    250391 Гость

    Вот код на С#, нужно перевести на Visual C++.
    Код (Text):
    1.using System;
    2.using System.Collections.Generic;
    3.using System.Linq;
    4.using System.Text;
    5.
    6.namespace MatrixShmatrix
    7.{
    8.  public class Matrix
    9.  {
    10. int n; //размеры матрицы
    11.     int m;
    12.     double[] a; // декларация указателей
    13.     double[] c;
    14.     public Matrix(int n, int m, int kod1)
    15.     {
    16.             int i;
    17.             int j;
    18.             Matrix.n =n;
    19.             Matrix.m =m;
    20.             a =new double[n]; // захват памяти под указатели
    21.             for(i =0;i<n;i++)
    22.                     a[i] =new double[m]; // захват памяти под элемент
    23.             c =new double[n];
    24.             for(int i =0; i<n; i++)
    25.                     c[i] =new double[m];
    26.    
    27.             // Заполнение массива элементами с клавиатуры
    28.             if(kod1 ==0)
    29.             {
    30.                     Console.WriteLine("\nВведите элементы матрицы:");
    31.                     for(i =0;i<n;i++)
    32.                             for(j =0;j<m;j++)
    33.                             {
    34.                                     Console.Write("a[");
    35.                                     Console.Write(i);
    36.                                     Console.Write("][");
    37.                                     Console.Write(j);
    38.                                     Console.Write("]=");
    39.                                     a[i][j] = SimulateCin.ReadToWhiteSpace(true);
    40.                             }
    41.                     Console.Write("\n");
    42.             }
    43.     }
    44.     public void Dispose()
    45.     {
    46.             for(int i =0;i<n;i++)
    47.                     a[i] = null; // освобождение памяти
    48.             a = null;
    49.     }
    50.
    51.     //*
    52.     // * @brief Сложение матриц
    53.     //
    54.     public static Matrix operator +(Matrix ImpliedObject, ref Matrix A)
    55.     {
    56.             for(int i =0; i<n; i++)
    57.                     for(int j =0; j<m; j++)
    58.                             c[i][j] =a[i][j]+A.a[i][j];
    59.    
    60.             return this;
    61.     }
    62.
    63.     //*
    64.     // * @brief Вычитание матриц
    65.     //
    66.     public static Matrix operator -(Matrix ImpliedObject, ref Matrix A)
    67.     {
    68.             for(int i =0; i<n; i++)
    69.                     for(int j =0; j<m; j++)
    70.                             c[i][j] =a[i][j]-A.a[i][j];
    71.    
    72.             return this;
    73.     }
    74.
    75.     //*
    76.     // * @brief Операция присваивания
    77.     //
    78.//C++ TO C# CONVERTER NOTE: This 'CopyFrom' method was converted from the original C++ copy assignment operator:
    79.//ORIGINAL LINE: Matrix &operator =(const Matrix &A)
    80.     public Matrix CopyFrom(Matrix A)
    81.     {
    82.             for(int i =0; i<n; i++)
    83.                     for(int j =0; j<m; j++)
    84.                             a[i][j] =A.c[i][j];
    85.             return this;
    86.     }
    87.
    88.     //*
    89.     // * @brief Умножение матриц
    90.     //
    91.     public static Matrix operator *(Matrix ImpliedObject,ref Matrix A)
    92.     {
    93.             double s =0;
    94.             for(int i =0;i<n;i++)
    95.                     {
    96.                             int z =0;
    97.                             while(z<A.m)
    98.                             {
    99.                                     c[i][z] =0;
    100.                                        for(int j =0;j<m;j++)
    101.                                        {
    102.                                                s =GetI(i, j)*A.GetI(j, z);
    103.                                                c[i][z]+=s;
    104.                                        }
    105.                                        z++;
    106.                                }
    107.                        }
    108.       
    109.                return this;
    110.        }
    111.
    112.        //*
    113.        // * @brief комбинированая операция "+="
    114.        //
    115.//C++ TO C# CONVERTER TODO TASK: The += operator cannot be overloaded in C#:
    116.        public static Matrix operator +( Matrix A)
    117.        {
    118.                for(int i =0; i<n; i++)
    119.                        for(int j =0; j<m; j++)
    120.                                a[i][j] =a[i][j]+A.a[i][j];
    121.       
    122.                return this;
    123.        }
    124.
    125.        //*
    126.        // * @brief комбинированая операция "-="
    127.        //
    128.//C++ TO C# CONVERTER TODO TASK: The -= operator cannot be overloaded in C#:
    129.        public static Matrix operator -( Matrix A)
    130.        {
    131.                for(int i =0; i<n; i++)
    132.                        for(int j =0; j<m; j++)
    133.                                a[i][j] =a[i][j]-A.a[i][j];
    134.       
    135.                return this;
    136.        }
    137.
    138.        //*
    139.        // * @brief Сравнение матриц
    140.        //
    141.        public static Matrix operator ==(Matrix ImpliedObject, ref Matrix A)
    142.        {
    143.                int f =0;
    144.                for(int i =0; i<n; i++)
    145.                {
    146.                        for(int j =0; j<m; j++)
    147.                                if(a[i][j]!=A.a[i][j])
    148.                                {
    149.                                        Console.Write("\nМатрицы не равны!!!\n");
    150.                                        f =1;
    151.                                        break;
    152.                                }
    153.                        if(f ==1)
    154.                                break;
    155.                }
    156.                if(f ==0)
    157.                {
    158.                        Console.Write("\nМатрицы равны!\n");
    159.                }
    160.       
    161.                return this;
    162.        }
    163.
    164.    public static Matrix operator !=(Matrix ImpliedObject,ref Matrix A)
    165.    {
    166.        int f = 0;
    167.        for (int i = 0; i < n; i++)
    168.        {
    169.            for (int j = 0; j < m; j++)
    170.                if (a[i][j] != A.a[i][j])
    171.                {
    172.                    Console.Write("\nМатрицы равны!!!\n");
    173.                    f = 1;
    174.                    break;
    175.                }
    176.            if (f == 1)
    177.                break;
    178.        }
    179.        if (f == 0)
    180.        {
    181.            Console.Write("\nМатрицы не равны!\n");
    182.        }
    183.
    184.        return this;
    185.    }
    186.
    187.        //*
    188.        // * @brief Транспонирование матрицы
    189.        //
    190.        public void Transp()
    191.        {
    192.                c =new double[m];
    193.                for(int i =0;i<m;i++)
    194.                        c[i] =new double[n]; // захват памяти под элемент
    195.                for(int i =0; i<n; i++)
    196.                        for(int j =0; j<m; j++)
    197.                                c[j][i] =a[i][j];
    198.       
    199.                for(int i =0;i<n;i++)
    200.                        a[i] = null; // освобождение памяти
    201.                a = null;
    202.       
    203.                a =new double[m];
    204.                for(int i =0;i<m;i++)
    205.                        a[i] =new double[n]; // захват памяти под элемент
    206.       
    207.                for(int i =0; i<m; i++)
    208.                        for(int j =0; j<n; j++)
    209.                                a[i][j] =c[i][j];
    210.       
    211.                        Matrix.n =m;
    212.                        Matrix.m =n;
    213.       
    214.        }
    215.
    216.        //*
    217.        // * @brief Вывод матрицы
    218.        //
    219.        public void Print(int n, int m)
    220.        {
    221.                for(int i =0; i<n; i++)
    222.                {
    223.                        for(int j =0; j<m; j++)
    224.                                Console.Write("{0,8:f2} ",GetI(i, j));
    225.                        Console.Write("\n");
    226.                }
    227.        }
    228.
    229.        //*
    230.        // * @brief Возведение в степень матрицы
    231.        //
    232.        public void Spep(int v)
    233.        {
    234.                int k =1;
    235.                do
    236.                {
    237.                double s =0;
    238.                for(int i =0;i<n;i++)
    239.                        {
    240.                                int z =0;
    241.                                while(z<m)
    242.                                {
    243.                                        c[i][z] =0;
    244.                                        for(int j =0;j<m;j++)
    245.                                        {
    246.                                                s =a[i][j]*a[j][z];
    247.                                                c[i][z]+=s;
    248.                                        }
    249.                                        z++;
    250.                                }
    251.                        }
    252.                k++;
    253.                }
    254.                while(k!=v);
    255.       
    256.                for(int i =0; i<m; i++)
    257.                        for(int j =0; j<n; j++)
    258.                                a[i][j] =c[i][j];
    259.        }
    260.        //*
    261.        // * @brief Проверки
    262.        //
    263.        public void Proverka()
    264.        {
    265.                int h =0;
    266.                for(int i =0; i<n; i++)
    267.                {
    268.                        for(int j =0; j<m; j++)
    269.                                if(a[i][j]!=0)
    270.                                {
    271.                                        if(i!=j)
    272.                                        {
    273.                                                Console.Write("Матрица №1 не диалогальная");
    274.                                                h =1;
    275.                                                break;
    276.                                        }
    277.                                }
    278.                        if(h ==1)
    279.                                break;
    280.                }
    281.                if(h ==0)
    282.                {
    283.                        Console.Write("Матрица №1 диалогальная");
    284.                        Console.Write("\n");
    285.                }
    286.                h =0;
    287.                for(int i =0; i<n; i++)
    288.                {
    289.                        for(int j =0; j<m; j++)
    290.                                if(a[i][j]!=0)
    291.                                {
    292.                                        Console.Write("М\nатрица №1 не нулевая");
    293.                                        Console.Write("\n");
    294.                                        h =2;
    295.                                        break;
    296.                                }
    297.                        if(h ==2)
    298.                                break;
    299.                }
    300.                if(h ==0)
    301.                {
    302.                        Console.Write("\nМатрица №1 нулевая");
    303.                        Console.Write("\n");
    304.                }
    305.                h =0;
    306.                for(int i =0; i<n; i++)
    307.                {
    308.                        for(int j =0; j<m; j++)
    309.                                if(a[i][j]!=1)
    310.                                {
    311.                                        Console.Write("Матрица №1 не единичная");
    312.                                        Console.Write("\n");
    313.                                        h =2;
    314.                                        break;
    315.                                }
    316.                        if(h ==2)
    317.                                break;
    318.                }
    319.                if(h ==0)
    320.                {
    321.                        Console.Write("Матрица №1 единичная");
    322.                        Console.Write("\n");
    323.                }
    324.       
    325.                int k =0;
    326.                int l =1;
    327.                int r =0;
    328.                if(n ==m)
    329.                {
    330.                for(int i =1; i<n; i++)
    331.                {
    332.                        for(int j =0; j<m; j++)
    333.                        {
    334.                                if(i>j)
    335.                                {
    336.                                        for(k; k<n; k++)
    337.                                        {
    338.                                                for(l; l<m; l++)
    339.                                                {
    340.                                                                if(a[i][k]!=a[k][l])
    341.                                                                {
    342.                                                                        Console.Write("Матрица не симетричная.");
    343.                                                                        Console.Write("\n");
    344.                                                                        r =1;
    345.                                                                        break;
    346.                                                                }
    347.                                                }
    348.                                                        if(r ==1)
    349.                                                                break;
    350.                                        }
    351.                                }
    352.                        if(r ==1)
    353.                                break;
    354.                        }
    355.                        if(r ==1)
    356.                                break;
    357.                }
    358.                if(r ==0)
    359.                {
    360.                        Console.Write("Матрица симетричная");
    361.                        Console.Write("\n");
    362.                }
    363.                }
    364.                else
    365.                {
    366.                        Console.Write("Матрица не симетричная");
    367.                        Console.Write("\n");
    368.                }
    369.        }
    370.
    371.        //*
    372.        // * @brief Проверка на треугольность
    373.        //
    374.        public void Treug()
    375.        {
    376.                int r =0;
    377.                for(int i =0; i<n; i++)
    378.                {
    379.                        for(int j =0; j<m; j++)
    380.                                if(i>j)
    381.                                {
    382.                                        if(a[i][j]!=0)
    383.                                        {
    384.                                                Console.Write("\nМатрица №1 не является верхняя треугольная.");
    385.                                                Console.Write("\n");
    386.                                                r =1;
    387.                                                break;
    388.                                        }
    389.                                }
    390.                        if(r ==1)
    391.                                break;
    392.                }
    393.       
    394.                if(r ==0)
    395.                {
    396.                        Console.Write("Матрица №1 является верхней треугольной.");
    397.                        Console.Write("\n");
    398.                }
    399.       
    400.                r =0;
    401.                for(int i =0; i<n; i++)
    402.                {
    403.                        for(int j =0; j<m; j++)
    404.                                if(i<j)
    405.                                {
    406.                                        if(a[i][j]!=0)
    407.                                        {
    408.                                                Console.Write("Матрица №1 не является нижней треугольной.");
    409.                                                Console.Write("\n");
    410.                                                r =2;
    411.                                                break;
    412.                                        }
    413.                                }
    414.                        if(r ==2)
    415.                                break;
    416.                }
    417.       
    418.                if(r ==0)
    419.                {
    420.                        Console.Write("Матрица №1 является нижней треугольной.");
    421.                        Console.Write("\n");
    422.                }
    423.        }
    424.
    425.        //*
    426.        // * @brief Умножение матрицы на число
    427.        //
    428.        public void Umnog(int z)
    429.        {
    430.                for(int i =0; i<n; i++)
    431.                        for(int j =0; j<m; j++)
    432.                                a[i][j] =a[i][j]*z;
    433.        }
    434.
    435.        //*
    436.        // * @brief Деление матрицы на число
    437.        //
    438.        public void Delenie(int z)
    439.        {
    440.                for(int i =0; i<n; i++)
    441.                        for(int j =0; j<m; j++)
    442.                                a[i][j] =a[i][j]/z;
    443.        }
    444.        public double GetI(int i, int j)
    445.        {
    446.                return a[i][j];
    447.        }
    448.}
    449.
    450.//----------------------------------------------------------------------------------------
    451.//   Copyright © 2006 - 2009 Tangible Software Solutions Inc.
    452.//   This class can be used by anyone provided that the copyright notice remains intact.
    453.//
    454.//   This class provides the ability to convert basic C++ 'cin' behavior.
    455.//----------------------------------------------------------------------------------------
    456.internal static class SimulateCin
    457.{
    458.        private static bool goodlastread = false;
    459.        internal static bool LastReadWasGood
    460.        {
    461.                get
    462.                {
    463.                        return goodlastread;
    464.                }
    465.        }
    466.
    467.        internal static string ReadToWhiteSpace(bool skipleadingwhitespace)
    468.        {
    469.                string input = "";
    470.                char nextchar;
    471.                if (skipleadingwhitespace)
    472.                {
    473.                        while (char.IsWhiteSpace(nextchar = (char)Console.Read()))
    474.                        {
    475.                        }
    476.                        input += nextchar;
    477.                }
    478.                while ( ! char.IsWhiteSpace(nextchar = (char)Console.Read()))
    479.                {
    480.                        input += nextchar;
    481.                }
    482.                goodlastread = input.Length > 0;
    483.                return input;
    484.        }
    485.    }
    486.    class Program
    487.    {
    488.        static void Main(string[] args)
    489.        {
    490.            int kod;
    491.                int p; // размеры для матриц
    492.                int h;
    493.                int q;
    494.                int w;
    495.                Matrix[] A = new Matrix[3]; // создание массива указателей класса Matrix
    496.
    497.                Console.Write("\nВведите размеры 1-й марицы:\n Количество строк n=");
    498.                p = Int32.Parse(Console.ReadLine());
    499.                Console.Write(" Количество столбцов m=");
    500.                h = Int32.Parse(Console.ReadLine());
    501.                A[0] =new Matrix(p, h, 0);
    502.                Console.Write("\nВведите размеры 2-й марицы:\n Количество строк k=");
    503.        q = Int32.Parse(Console.ReadLine());
    504.                Console.Write(" Количество столбцов l=");
    505.        w = Int32.Parse(Console.ReadLine());
    506.                A[1] =new Matrix(q, w, 0);
    507.                Console.Write("\tМатрица №1\n");
    508.                Console.Write("\n");
    509.                A[0].Print(p, h);
    510.                Console.Write("\n\tМатрица №2\n");
    511.                Console.Write("\n");
    512.                A[1].Print(q, w);
    513.                while(true)
    514.                {
    515.                        Console.Write("\nВыберите операции над матрицами:\n\t1.Сложение, вычитание,умножение,деление.\n\t2.Комбинированные операции присваивания.\n\t3.Сравнения на равенство/неравенство");
    516.                        Console.Write("\n\t4.Вычисление транспонированной матрицы\n\t5.Возведения в степень\n\t6.Квадратная, диагональная, нулевая, единичная, симетричная");
    517.                        Console.Write("\n\t7.Проверка на верхняя или нижняя треугольная.\n\t8.Ввести новые матрицы.\n\t0.Выход:");
    518.                        kod = Int32.Parse(Console.ReadLine());
    519.                        switch(kod)
    520.                        {
    521.                        case 1:
    522.                                Console.Write("\n1.Сложение.\n2.Вычитание.\n3.Умножение.\n4.Деление:");
    523.                                int kod1;
    524.                                kod1 = Int32.Parse(Console.ReadLine());
    525.                                switch(kod1)
    526.                                {
    527.                                case 1:
    528.                                        Console.Write("\n****Сложение:*****\n\n");
    529.                                        if(p ==q && h ==w)
    530.                                        {
    531.                                                A[2] = new Matrix(q, w, 1);
    532.                                                (A[2])=((A[0]) + (A[1]));
    533.                                                A[2].Print(q, w);
    534.                                                A[2] = null;
    535.                                        }
    536.
    537.                                        else
    538.                                        {
    539.                                                Console.Write("-----Слаживаются матрицы одинаковых размеров!!!----\n");
    540.                                        }
    541.                                        break;
    542.
    543.                                case 2:
    544.                                        Console.Write("\n****Вычитание:******\n\n");
    545.                                        if(p ==q && h ==w)
    546.                                        {
    547.                                                A[2] = new Matrix(q, w, 1);
    548.                                                (A[2])=(A[0]) - (A[1]);
    549.                                                A[2].Print(q, w);
    550.                                                A[2] = null;
    551.                                        }
    552.                                        else
    553.                                        {
    554.                                                Console.Write("----Матрицы должны быть одинаковых размеров!!!----\n");
    555.                                        }
    556.                                        break;
    557.                                case 3:
    558.                                        Console.Write("\n****Умножение:******\n\n");
    559.                                        int z;
    560.                                        Console.Write("1. Умножение матриц на число.\n2. Умножение матрицы на матрицу:");
    561.                                        z = Int32.Parse(Console.ReadLine());
    562.                                        A[2] = new Matrix(p, w, 1);
    563.                                        if(z ==2)
    564.                                        {
    565.                                                if(h ==q)
    566.                                                {
    567.                                                        (A[2])=((A[0]) * (A[1]));
    568.                                                        Console.Write("\n\tПроизведение матриц:\n");
    569.                                                        A[2].Print(p, w);
    570.                                                        A[2] = null;
    571.                                                }
    572.                                                else
    573.                                                {
    574.                                                        Console.Write("----Умножаются матрицы размеров NxM и KxL, если M=K!!!!!-----\n");
    575.                                                }
    576.                                        }
    577.
    578.                                        else
    579.                                        {
    580.                                                double u;
    581.                                                Console.Write("Введите коофициент умножения:");
    582.                                                u = Int32.Parse(Console.ReadLine());
    583.                                                Console.Write("\n\tМатрица №1:\n");
    584.                                                Console.Write("\n");
    585.                                                A[0].Umnog(u);
    586.                                                A[0].Print(p, h);
    587.
    588.                                        }
    589.                                        break;
    590.                                case 4:
    591.                                        int u;
    592.                                        Console.Write("\nДеление матрицы на чило. Введите число:");
    593.                                        u = Int32.Parse(Console.ReadLine());
    594.                                        if(u ==0)
    595.                                        {
    596.                                                Console.Write("\nНа 0 делить нельзя!!!\n");
    597.                                        }
    598.                                        else
    599.                                        {
    600.                                                Console.Write("\n\tМатрица №1:\n");
    601.                                                Console.Write("\n");
    602.                                                A[0].Delenie(u);
    603.                                                A[0].Print(p, h);
    604.                                        }
    605.                                        break;
    606.                                }
    607.                        break;
    608.
    609.                        case 2:
    610.                                if(p ==q && h ==w)
    611.                                {
    612.                                        Console.Write("\nОперация '+='(A+=B)\nМатрица №1:\n");
    613.                                        Console.Write("\n");
    614.                                        (A[0])+=(A[1]);
    615.                                        A[0].Print(p, h);
    616.                                        Console.Write("\nОперация '-='(A-=B)\nМатрица №1:\n");
    617.                                        Console.Write("\n");
    618.                                        (A[0])-=(A[1]);
    619.                                        A[0].Print(p, h);
    620.                                }
    621.                                else
    622.                                {
    623.                                        Console.Write("\nМатрицы должны быть одинаковых размеров!\n");
    624.                                }
    625.                                break;
    626.
    627.                        case 3:
    628.                                if(p ==q && h ==w)
    629.                                        (A[0])==(A[1]);
    630.                                else
    631.                                {
    632.                                        Console.Write("\nМатрицы должны быть одинаковых размеров!\n");
    633.                                }
    634.                                break;
    635.
    636.                        case 4:
    637.                                Console.Write("\nТранспонированая матрица №1:\n");
    638.                                Console.Write("\n");
    639.                                A[0].Transp();
    640.                                A[0].Print(h, p);
    641.                                break;
    642.
    643.                        case 5:
    644.                                if(p ==h)
    645.                                {
    646.                                        int v;
    647.                                        Console.Write("\nВведети степень:");
    648.                                        Console.Write("\n");
    649.                                        v = Int32.Parse(Console.ReadLine());
    650.                                        Console.Write("\nВозведение матрицы №1 в степень:\n");
    651.                                        Console.Write("\n");
    652.                                        A[0].Spep(v);
    653.                                        A[0].Print(p, h);
    654.                                }
    655.                                else
    656.                                {
    657.                                        Console.Write("\nНужно ввести квадратную матрицу!!!\n");
    658.                                }
    659.                                break;
    660.
    661.                        case 6:
    662.                                Console.Write("Проверка для матрицы №1");
    663.                                Console.Write("\n");
    664.                                if(p ==h)
    665.                                {
    666.                                        Console.Write("\nМатрица №1 квадратная.\n");
    667.                                }
    668.                                else
    669.                                {
    670.                                        Console.Write("\nМатрица №1 не квадратная.\n");
    671.                                }
    672.                                A[1].Proverka();
    673.                                break;
    674.
    675.                        case 7:
    676.                                Console.Write("Проверка для матрицы №1");
    677.                                Console.Write("\n");
    678.                                A[0].Treug();
    679.                                break;
    680.
    681.                        case 8:
    682.                                for(int i =0; i<2; i++)
    683.                                        A[i] = null;
    684.                                Console.Write("\nВведите размеры 1-й марицы:\n Количество строк n=");
    685.                                p = Int32.Parse(Console.ReadLine());
    686.                                Console.Write(" Количество столбцов m=");
    687.                                h = Int32.Parse(Console.ReadLine());
    688.                                A[0] =new Matrix(p, h, 0);
    689.                                Console.Write("\nВведите размеры 2-й марицы:\n Количество строк k=");
    690.                                q = Int32.Parse(Console.ReadLine());
    691.                                Console.Write(" Количество столбцов l=");
    692.                                w = Int32.Parse(Console.ReadLine());
    693.                                A[1] =new Matrix(q, w, 0);
    694.                                Console.Write("\tМатрица №1\n");
    695.                                Console.Write("\n");
    696.                                A[0].Print(p, h);
    697.                                Console.Write("\n\tМатрица №2\n");
    698.                                Console.Write("\n");
    699.                                A[1].Print(q, w);
    700.                        break;
    701.
    702.                        case 0:
    703.                                for(int i =0; i<2; i++)
    704.                                        A[i] = null;
    705.                                 return 0;
    706.                        }
    707.                }
    708.        }
    709.}
    710.        }
     
Загрузка...
Похожие Темы - Вещественная Матрица
  1. fatpunk
    Ответов:
    0
    Просмотров:
    1.136
  2. нини
    Ответов:
    3
    Просмотров:
    1.744
  3. phobiaxx
    Ответов:
    1
    Просмотров:
    1.277
  4. vladis222
    Ответов:
    1
    Просмотров:
    1.285
  5. LudmilaUt
    Ответов:
    0
    Просмотров:
    1.383

Поделиться этой страницей