ThaoWells_lab5.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "id": "Vzst_m_4sE1F"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "class Matrix:\n",
        "\n",
        "  def __init__(self, n=0, m=0):#didn't work without this lol\n",
        "        self.setup(n, m)\n",
        "\n",
        "\n",
        "  def setup(self, n=0, m=0): #initial values at 0\n",
        "    if n != 0: #if n input doesn't equal 0 (presence of input)\n",
        "      self.n =n #set class argument to n variable value\n",
        "    if m != 0: #repeats\n",
        "      self.m =m\n",
        "      self.matrix = [[0]*n for i in range(m)] #creates list (matrix) with all values being 0, iterates an m amount of times\n",
        "  def printmatrix(self):\n",
        "    print('MATRIX', [self.n], 'by', [self.m])\n",
        "    if self.matrix and self.matrix[1][1] is not None:\n",
        "      for row in self.matrix:\n",
        "        for element in row:#for each element in row in matrix\n",
        "          print(element, end='')\n",
        "        print() #tjis is new line after row\n",
        "    else:\n",
        "      print(\"matrix is empty\")\n",
        "\n",
        "\n",
        "  def index(self, *args):\n",
        "        if len(args) == 2: #if length of arguments has 2 inputs, which will be i, j, then it will\n",
        "            i, j = args\n",
        "            return self.get_element(i, j) #calls individual element, and below, individual rows\n",
        "        elif len(args) == 1:\n",
        "            i, = args\n",
        "            return self.get_row(i)\n",
        "\n",
        "        else:\n",
        "            raise TypeError(\"nuh uh\") #returns error\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#test\n",
        "matrixa = Matrix()\n",
        "matrixa.setup(5,6)\n",
        "matrixa.printmatrix()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CP3J5P5LMLGu",
        "outputId": "4e0c248d-e8c5-48bf-bb6e-8de05d3fec35"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MATRIX [5] by [6]\n",
            "00000\n",
            "00000\n",
            "00000\n",
            "00000\n",
            "00000\n",
            "00000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "class Matrix:\n",
        "\n",
        "  def __init__(self, n=0, m=0):\n",
        "        self.setup(n, m)\n",
        "\n",
        "  def setup(self, n=0, m=0): #initial values at 0\n",
        "    if n != 0: #if n input doesn't equal 0 (presence of input)\n",
        "      self.n =n #set class argument to n variable value\n",
        "    if m != 0: #repeats\n",
        "      self.m =m\n",
        "      self.matrix = [[0]*n for i in range(m)] #creates list (matrix) with all values being 0, iterates an m amount of times\n",
        "  def printmatrix(self):\n",
        "    print('MATRIX', [self.n], 'by', [self.m])\n",
        "    if self.matrix and self.matrix[1][1] is not None:\n",
        "      for row in self.matrix:\n",
        "        for element in row:#for each element in row in matrix\n",
        "          print(element, end='')\n",
        "        print() #tjis is new line after row\n",
        "    else:\n",
        "      print(\"matrix is empty\")\n",
        "\n",
        "\n",
        "  def index(self, *args):\n",
        "        if len(args) == 2: #if length of arguments has 2 inputs, which will be i, j, then it will\n",
        "            i, j = args\n",
        "            return self.get_element(i, j) #calls individual element, and below, individual rows\n",
        "        elif len(args) == 1:\n",
        "            i, = args\n",
        "            return self.get_row(i)\n",
        "\n",
        "        else:\n",
        "            raise TypeError(\"nuh uh\") #returns error\n",
        "\n",
        "  def equalize(self, og):\n",
        "        if not isinstance(og, Matrix):\n",
        "            raise ValueError(\"nuh uh\")\n",
        "        if self.n != og.n or self.m != og.m:\n",
        "            raise ValueError(\"nuh uh wrong size. must be equal sized matrixes\")\n",
        "        self.matrix = [row[:] for row in og.matrix]  # copies from matrix to new matrix\n"
      ],
      "metadata": {
        "id": "5G_pCSaKZrJN"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = Matrix()\n",
        "b = Matrix()\n",
        "a.setup(2,2)\n",
        "b.setup(2,2)\n",
        "\n",
        "a.matrix=[[8, 8], [3, 4]]\n",
        "b.matrix = [[10, 3], [7, 9]]\n",
        "\n",
        "\n",
        "b.equalize(a)\n",
        "\n",
        "a.printmatrix()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KjFUkVzRZxC1",
        "outputId": "a0a1a979-2161-4f0c-d7be-1c02895d2be8"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MATRIX [2] by [2]\n",
            "88\n",
            "34\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#2"
      ],
      "metadata": {
        "id": "bF6OodQIa68k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "class Matrix:\n",
        "\n",
        "  def __init__(self, n=0, m=0):\n",
        "        self.setup(n, m)\n",
        "\n",
        "  def setup(self, n=0, m=0): #initial values at 0\n",
        "    if n != 0: #if n input doesn't equal 0 (presence of input)\n",
        "      self.n =n #set class argument to n variable value\n",
        "    if m != 0: #repeats\n",
        "      self.m =m\n",
        "      self.matrix = [[0]*n for i in range(m)] #creates list (matrix) with all values being 0, iterates an m amount of times\n",
        "  def printmatrix(self):\n",
        "    print('MATRIX', [self.n], 'by', [self.m])\n",
        "    if self.matrix and self.matrix[1][1] is not None:\n",
        "      for row in self.matrix:\n",
        "        for element in row:#for each element in row in matrix\n",
        "          print(element, end='')\n",
        "        print() #tjis is new line after row\n",
        "    else:\n",
        "      print(\"matrix is empty\")\n",
        "\n",
        "\n",
        "  def index(self, *args):\n",
        "        if len(args) == 2: #if length of arguments has 2 inputs, which will be i, j, then it will\n",
        "            i, j = args\n",
        "            return self.get_element(i, j) #calls individual element, and below, individual rows\n",
        "        elif len(args) == 1:\n",
        "            i, = args\n",
        "            return self.get_row(i)\n",
        "\n",
        "        else:\n",
        "            raise TypeError(\"nuh uh\") #returns error\n",
        "\n",
        "  def equalize(self, og):\n",
        "        if not isinstance(og, Matrix):\n",
        "            raise ValueError(\"nuh uh\")\n",
        "        if self.n != og.n or self.m != og.m:\n",
        "            raise ValueError(\"nuh uh wrong size. must be equal sized matrixes\")\n",
        "        self.matrix = [row[:] for row in og.matrix]  # copies from matrix to new matrix\n",
        "\n",
        "  def shape(self):\n",
        "        return (self.n, self.m)\n",
        "\n",
        "  def transpose(self):\n",
        "        t_matrix = [[self.matrix[i][j] for j in range(self.m)] for i in range(self.n)]\n",
        "        t = Matrix(self.m, self.n)\n",
        "        t.matrix = t_matrix\n",
        "        return t"
      ],
      "metadata": {
        "id": "PZHlqW9va8Mc"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "m=Matrix(2,2)\n",
        "m.setup(2,2)\n",
        "m.printmatrix()\n",
        "m.shape()\n",
        "m.matrix = [[1, 2, 3], [4, 5, 6]]\n",
        "\n",
        "# Transpose the matrix\n",
        "transposedm = m.transpose()\n",
        "\n",
        "# Print the original and transposed matrices\n",
        "print(\"Og matrix:\")\n",
        "m.printmatrix()\n",
        "\n",
        "print(\"\\nTransposed Matrix:\")\n",
        "transposedm.printmatrix()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dzQ8mI8bbkeM",
        "outputId": "df467942-7731-4f1a-8c7f-e9c68051ea5f"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MATRIX [2] by [2]\n",
            "00\n",
            "00\n",
            "Og matrix:\n",
            "MATRIX [2] by [2]\n",
            "123\n",
            "456\n",
            "\n",
            "Transposed Matrix:\n",
            "MATRIX [2] by [2]\n",
            "12\n",
            "45\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "class Matrix:\n",
        "\n",
        "  def __init__(self, n=0, m=0):\n",
        "        self.setup(n, m)\n",
        "\n",
        "  def setup(self, n=0, m=0): #initial values at 0\n",
        "    if n != 0: #if n input doesn't equal 0 (presence of input)\n",
        "      self.n =n #set class argument to n variable value\n",
        "    if m != 0: #repeats\n",
        "      self.m =m\n",
        "      self.matrix = [[0]*n for i in range(m)] #creates list (matrix) with all values being 0, iterates an m amount of times\n",
        "  def printmatrix(self):\n",
        "    print('MATRIX', [self.n], 'by', [self.m])\n",
        "    if self.matrix and self.matrix[1][1] is not None:\n",
        "      for row in self.matrix:\n",
        "        for element in row:#for each element in row in matrix\n",
        "          print(element, end='')\n",
        "        print() #tjis is new line after row\n",
        "    else:\n",
        "      print(\"matrix is empty\")\n",
        "\n",
        "\n",
        "  def index(self, *args):\n",
        "        if len(args) == 2: #if length of arguments has 2 inputs, which will be i, j, then it will\n",
        "            i, j = args\n",
        "            return self.get_element(i, j) #calls individual element, and below, individual rows\n",
        "        elif len(args) == 1:\n",
        "            i, = args\n",
        "            return self.get_row(i)\n",
        "\n",
        "        else:\n",
        "            raise TypeError(\"nuh uh\") #returns error\n",
        "\n",
        "  def equalize(self, og):\n",
        "        if not isinstance(og, Matrix):\n",
        "            raise ValueError(\"nuh uh\")\n",
        "        if self.n != og.n or self.m != og.m:\n",
        "            raise ValueError(\"nuh uh wrong size. must be equal sized matrixes\")\n",
        "        self.matrix = [row[:] for row in og.matrix]  # copies from matrix to new matrix\n",
        "\n",
        "  def shape(self):\n",
        "        return (self.n, self.m)\n",
        "\n",
        "  def transpose(self):\n",
        "        t_matrix = [[self.matrix[i][j] for j in range(self.m)] for i in range(self.n)]\n",
        "        t = Matrix(self.m, self.n)\n",
        "        t.matrix = t_matrix\n",
        "        return t\n",
        "\n",
        "  def row(self, n):\n",
        "    if not 0 <= n < self.m: #n got to between values of 0(or equal to) and m instance\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[self.matrix[n]]) #specific row"
      ],
      "metadata": {
        "id": "5TunSfBdd3_x"
      },
      "execution_count": 43,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#test\n",
        "#didn't work"
      ],
      "metadata": {
        "id": "U9Vt7Goaecvi"
      },
      "execution_count": 77,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "class Matrix:\n",
        "\n",
        "  def __init__(self, n=0, m=0):\n",
        "        self.setup(n, m)\n",
        "\n",
        "  def setup(self, n=0, m=0): #initial values at 0\n",
        "    if n != 0: #if n input doesn't equal 0 (presence of input)\n",
        "      self.n =n #set class argument to n variable value\n",
        "    if m != 0: #repeats\n",
        "      self.m =m\n",
        "      self.matrix = [[0]*n for i in range(m)] #creates list (matrix) with all values being 0, iterates an m amount of times\n",
        "  def printmatrix(self):\n",
        "    print('MATRIX', [self.n], 'by', [self.m])\n",
        "    if self.matrix and self.matrix[1][1] is not None:\n",
        "      for row in self.matrix:\n",
        "        for element in row:#for each element in row in matrix\n",
        "          print(element, end='')\n",
        "        print() #tjis is new line after row\n",
        "    else:\n",
        "      print(\"matrix is empty\")\n",
        "\n",
        "\n",
        "  def index(self, *args):\n",
        "        if len(args) == 2: #if length of arguments has 2 inputs, which will be i, j, then it will\n",
        "            i, j = args\n",
        "            return self.get_element(i, j) #calls individual element, and below, individual rows\n",
        "        elif len(args) == 1:\n",
        "            i, = args\n",
        "            return self.get_row(i)\n",
        "\n",
        "        else:\n",
        "            raise TypeError(\"nuh uh\") #returns error\n",
        "\n",
        "  def equalize(self, og):\n",
        "        if not isinstance(og, Matrix):\n",
        "            raise ValueError(\"nuh uh\")\n",
        "        if self.n != og.n or self.m != og.m:\n",
        "            raise ValueError(\"nuh uh wrong size. must be equal sized matrixes\")\n",
        "        self.matrix = [row[:] for row in og.matrix]  # copies from matrix to new matrix\n",
        "\n",
        "  def shape(self):\n",
        "        return (self.n, self.m)\n",
        "\n",
        "  def transpose(self):\n",
        "        t_matrix = [[self.matrix[i][j] for j in range(self.m)] for i in range(self.n)]\n",
        "        t = Matrix(self.m, self.n)\n",
        "        t.matrix = t_matrix\n",
        "        return t\n",
        "\n",
        "  def row(self, n):\n",
        "    if not 0 <= n < self.m: #n got to between values of 0(or equal to) and m instance\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[self.matrix[n]]) #specific row\n",
        "\n",
        "\n",
        "  def column(self, n): #kinda does the same thing as above, but column wise. same args slightly dif execution\n",
        "    if not 0 <= n < self.n:\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[[self.matrix[i][n]] for i in range(self.m)])\n",
        "\n",
        "  def to_list(self): #returns matrix as list of lists\n",
        "    return [row[:] for row in self.matrix]"
      ],
      "metadata": {
        "id": "tEf9sA9Iejr_"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#test\n",
        "#didn't work"
      ],
      "metadata": {
        "id": "zSqdFh8_e5ny"
      },
      "execution_count": 76,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "class Matrix:\n",
        "\n",
        "  def __init__(self, n=0, m=0):\n",
        "        self.setup(n, m)\n",
        "\n",
        "  def setup(self, n=0, m=0): #initial values at 0\n",
        "    if n != 0: #if n input doesn't equal 0 (presence of input)\n",
        "      self.n =n #set class argument to n variable value\n",
        "    if m != 0: #repeats\n",
        "      self.m =m\n",
        "      self.matrix = [[0]*n for i in range(m)] #creates list (matrix) with all values being 0, iterates an m amount of times\n",
        "  def printmatrix(self):\n",
        "    print('MATRIX', [self.n], 'by', [self.m])\n",
        "    if self.matrix and self.matrix[1][1] is not None:\n",
        "      for row in self.matrix:\n",
        "        for element in row:#for each element in row in matrix\n",
        "          print(element, end='')\n",
        "        print() #tjis is new line after row\n",
        "    else:\n",
        "      print(\"matrix is empty\")\n",
        "\n",
        "\n",
        "  def index(self, *args):\n",
        "        if len(args) == 2: #if length of arguments has 2 inputs, which will be i, j, then it will\n",
        "            i, j = args\n",
        "            return self.get_element(i, j) #calls individual element, and below, individual rows\n",
        "        elif len(args) == 1:\n",
        "            i, = args\n",
        "            return self.get_row(i)\n",
        "\n",
        "        else:\n",
        "            raise TypeError(\"nuh uh\") #returns error\n",
        "\n",
        "  def equalize(self, og):\n",
        "        if not isinstance(og, Matrix):\n",
        "            raise ValueError(\"nuh uh\")\n",
        "        if self.n != og.n or self.m != og.m:\n",
        "            raise ValueError(\"nuh uh wrong size. must be equal sized matrixes\")\n",
        "        self.matrix = [row[:] for row in og.matrix]  # copies from matrix to new matrix\n",
        "\n",
        "  def shape(self):\n",
        "        return (self.n, self.m)\n",
        "\n",
        "  def transpose(self):\n",
        "        t_matrix = [[self.matrix[i][j] for j in range(self.m)] for i in range(self.n)]\n",
        "        t = Matrix(self.m, self.n)\n",
        "        t.matrix = t_matrix\n",
        "        return t\n",
        "\n",
        "  def row(self, n):\n",
        "    if not 0 <= n < self.m: #n got to between values of 0(or equal to) and m instance\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[self.matrix[n]]) #specific row\n",
        "\n",
        "\n",
        "  def column(self, n): #kinda does the same thing as above, but column wise. same args slightly dif execution\n",
        "    if not 0 <= n < self.n:\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[[self.matrix[i][n]] for i in range(self.m)])\n",
        "\n",
        "  def to_list(self): #returns matrix as list of lists\n",
        "    return [row[:] for row in self.matrix]\n",
        "\n",
        "\n",
        "  def block(self, n_0, n_1, m_0, m_1):\n",
        "    if not (0 <= n_0 < n_1 <= self.n) or not (0 <= m_0 < m_1 <= self.m):\n",
        "        raise ValueError(\"nuh uh\")\n",
        "    block_m = [row[n_0:n_1] for row in self.matrix[m_0:m_1]] #\n",
        "    return Matrix(matrix=block_m)"
      ],
      "metadata": {
        "id": "bfh27rZSfBNq"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#test\n",
        "#didn't work"
      ],
      "metadata": {
        "id": "0bLRM_3hflLd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#3"
      ],
      "metadata": {
        "id": "bCnpEaD-is_4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "class Matrix:\n",
        "\n",
        "  def __init__(self, n=0, m=0):\n",
        "        self.setup(n, m)\n",
        "\n",
        "  def setup(self, n=0, m=0): #initial values at 0\n",
        "    if n != 0: #if n input doesn't equal 0 (presence of input)\n",
        "      self.n =n #set class argument to n variable value\n",
        "    if m != 0: #repeats\n",
        "      self.m =m\n",
        "      self.matrix = [[0]*n for i in range(m)] #creates list (matrix) with all values being 0, iterates an m amount of times\n",
        "  def printmatrix(self):\n",
        "    print('MATRIX', [self.n], 'by', [self.m])\n",
        "    if self.matrix and self.matrix[1][1] is not None:\n",
        "      for row in self.matrix:\n",
        "        for element in row:#for each element in row in matrix\n",
        "          print(element, end='')\n",
        "        print() #tjis is new line after row\n",
        "    else:\n",
        "      print(\"matrix is empty\")\n",
        "\n",
        "\n",
        "  def index(self, *args):\n",
        "        if len(args) == 2: #if length of arguments has 2 inputs, which will be i, j, then it will\n",
        "            i, j = args\n",
        "            return self.get_element(i, j) #calls individual element, and below, individual rows\n",
        "        elif len(args) == 1:\n",
        "            i, = args\n",
        "            return self.get_row(i)\n",
        "\n",
        "        else:\n",
        "            raise TypeError(\"nuh uh\") #returns error\n",
        "\n",
        "  def equalize(self, og):\n",
        "        if not isinstance(og, Matrix):\n",
        "            raise ValueError(\"nuh uh\")\n",
        "        if self.n != og.n or self.m != og.m:\n",
        "            raise ValueError(\"nuh uh wrong size. must be equal sized matrixes\")\n",
        "        self.matrix = [row[:] for row in og.matrix]  # copies from matrix to new matrix\n",
        "\n",
        "  def shape(self):\n",
        "        return (self.n, self.m)\n",
        "\n",
        "  def transpose(self):\n",
        "        t_matrix = [[self.matrix[i][j] for j in range(self.m)] for i in range(self.n)]\n",
        "        t = Matrix(self.m, self.n)\n",
        "        t.matrix = t_matrix\n",
        "        return t\n",
        "\n",
        "  def row(self, n):\n",
        "    if not 0 <= n < self.m: #n got to between values of 0(or equal to) and m instance\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[self.matrix[n]]) #specific row\n",
        "\n",
        "\n",
        "  def column(self, n): #kinda does the same thing as above, but column wise. same args slightly dif execution\n",
        "    if not 0 <= n < self.n:\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[[self.matrix[i][n]] for i in range(self.m)])\n",
        "\n",
        "  def to_list(self): #returns matrix as list of lists\n",
        "    return [row[:] for row in self.matrix]\n",
        "\n",
        "\n",
        "  def block(self, n_0, n_1, m_0, m_1):\n",
        "    if not (0 <= n_0 < n_1 <= self.n) or not (0 <= m_0 < m_1 <= self.m):\n",
        "        raise ValueError(\"nuh uh\")\n",
        "    block_m = [row[n_0:n_1] for row in self.matrix[m_0:m_1]] #\n",
        "    return Matrix(matrix=block_m)\n",
        "\n",
        "  def constant(n, m, c):#constant value times columns for blank in range of n\n",
        "    return [[c] * m for _ in range(n)]\n",
        "\n",
        "  def zeros(n, m): #does like the same, but with zeroes\n",
        "    return constant(n, m, 0)\n",
        "\n",
        "  def ones(n, m): #now with ones\n",
        "    return constant(n, m, 1)\n",
        "\n",
        "\n",
        "  def eye(n): #basically creates rref\n",
        "    return [[1 if i == j else 0 for j in range(n)] for i in range(n)]"
      ],
      "metadata": {
        "id": "uulqpr8migW5"
      },
      "execution_count": 52,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#test\n",
        "a.printmatrix(constant(3, 2, 5))\n",
        "print()\n",
        "\n",
        "print(\"Zeros matrix:\")\n",
        "print(zeros(2, 3))\n",
        "print()\n",
        "\n",
        "print(\"Ones matrix:\")\n",
        "print(ones(2, 3))\n",
        "print()\n",
        "\n",
        "print(\"Identity matrix:\")\n",
        "print(eye(3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 211
        },
        "id": "7qDlNjpFjd4c",
        "outputId": "831b24f1-c0e5-451b-9c5b-d4fdd563678a"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'constant' is not defined",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-53-b81d8bffc67f>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#test\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprintmatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconstant\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Zeros matrix:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mNameError\u001b[0m: name 'constant' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#4\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "class Matrix:\n",
        "\n",
        "  def __init__(self, n=0, m=0):\n",
        "        self.setup(n, m)\n",
        "\n",
        "  def setup(self, n=0, m=0): #initial values at 0\n",
        "    if n != 0: #if n input doesn't equal 0 (presence of input)\n",
        "      self.n =n #set class argument to n variable value\n",
        "    if m != 0: #repeats\n",
        "      self.m =m\n",
        "      self.matrix = [[0]*n for i in range(m)] #creates list (matrix) with all values being 0, iterates an m amount of times\n",
        "  def printmatrix(self):\n",
        "    print('MATRIX', [self.n], 'by', [self.m])\n",
        "    if self.matrix and self.matrix[1][1] is not None:\n",
        "      for row in self.matrix:\n",
        "        for element in row:#for each element in row in matrix\n",
        "          print(element, end='')\n",
        "        print() #tjis is new line after row\n",
        "    else:\n",
        "      print(\"matrix is empty\")\n",
        "\n",
        "\n",
        "  def index(self, *args):\n",
        "        if len(args) == 2: #if length of arguments has 2 inputs, which will be i, j, then it will\n",
        "            i, j = args\n",
        "            return self.get_element(i, j) #calls individual element, and below, individual rows\n",
        "        elif len(args) == 1:\n",
        "            i, = args\n",
        "            return self.get_row(i)\n",
        "\n",
        "        else:\n",
        "            raise TypeError(\"nuh uh\") #returns error\n",
        "\n",
        "  def equalize(self, og):\n",
        "        if not isinstance(og, Matrix):\n",
        "            raise ValueError(\"nuh uh\")\n",
        "        if self.n != og.n or self.m != og.m:\n",
        "            raise ValueError(\"nuh uh wrong size. must be equal sized matrixes\")\n",
        "        self.matrix = [row[:] for row in og.matrix]  # copies from matrix to new matrix\n",
        "\n",
        "  def shape(self):\n",
        "        return (self.n, self.m)\n",
        "\n",
        "  def transpose(self):\n",
        "        t_matrix = [[self.matrix[i][j] for j in range(self.m)] for i in range(self.n)]\n",
        "        t = Matrix(self.m, self.n)\n",
        "        t.matrix = t_matrix\n",
        "        return t\n",
        "\n",
        "  def row(self, n):\n",
        "    if not 0 <= n < self.m: #n got to between values of 0(or equal to) and m instance\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[self.matrix[n]]) #specific row\n",
        "\n",
        "\n",
        "  def column(self, n): #kinda does the same thing as above, but column wise. same args slightly dif execution\n",
        "    if not 0 <= n < self.n:\n",
        "        raise IndexError(\"nuh uh\")\n",
        "    return Matrix(matrix=[[self.matrix[i][n]] for i in range(self.m)])\n",
        "\n",
        "  def to_list(self): #returns matrix as list of lists\n",
        "    return [row[:] for row in self.matrix]\n",
        "\n",
        "\n",
        "  def block(self, n_0, n_1, m_0, m_1):\n",
        "    if not (0 <= n_0 < n_1 <= self.n) or not (0 <= m_0 < m_1 <= self.m):\n",
        "        raise ValueError(\"nuh uh\")\n",
        "    block_m = [row[n_0:n_1] for row in self.matrix[m_0:m_1]] #\n",
        "    return Matrix(matrix=block_m)\n",
        "\n",
        "  def constant(n, m, c):#constant value times columns for blank in range of n\n",
        "    return [[c] * m for _ in range(n)]\n",
        "\n",
        "  def zeros(n, m): #does like the same, but with zeroes\n",
        "    return constant(n, m, 0)\n",
        "\n",
        "  def ones(n, m): #now with ones\n",
        "    return constant(n, m, 1)\n",
        "\n",
        "\n",
        "  def eye(n): #basically creates rref\n",
        "    return [[1 if i == j else 0 for j in range(n)] for i in range(n)]\n",
        "\n",
        "  def scalarmul(self, scalar):\n",
        "    result = Matrix(self.n, self.m)\n",
        "    for i in range(self.n):\n",
        "      for j in range(self.m):\n",
        "        result.matrix[i][j] = self.matrix[i][j] * scalar\n",
        "    return result\n",
        "\n",
        "\n",
        "\n",
        "  def add(self, N): #adding\n",
        "      if self.n != N.n or self.m != N.m:\n",
        "          raise ValueError(\"nuh uh\")\n",
        "      return Matrix(self.n, self.m, matrix=[[self.matrix[i][j] + N.matrix[i][j] for j in range(self.n)] for i in range(self.m)])#does the same thing but adding\n",
        "\n",
        "  def sub(self, N):\n",
        "      if self.n != N.n or self.m != N.m:\n",
        "          raise ValueError(\"nuh uh\")\n",
        "      return Matrix(self.n, self.m, matrix=[[self.matrix[i][j] - N.matrix[i][j] for j in range(self.n)] for i in range(self.m)])#same but subtracting\n",
        "\n",
        "  def mat_mult(self, N):\n",
        "      if self.m != N.n:\n",
        "          raise ValueError(\"nuhuh\")\n",
        "      return Matrix(N.n, self.m, matrix=[[sum(self.matrix[i][k] * N.matrix[k][j] for k in range(self.n)) for j in range(N.n)] for i in range(self.m)])#same but multiplying matrices\n",
        "\n",
        "  def element_mult(self, N):\n",
        "    if self.n != N.n or self.m != N.m:\n",
        "          raise ValueError(\"nuhuh\")\n",
        "    return Matrix(self.n, self.m, matrix=[[self.matrix[i][j] * N.matrix[i][j] for j in range(self.n)] for i in range(self.m)])\n",
        "\n",
        "  def equals(self, N):\n",
        "    return self.matrix == N.matrix #returns true or false"
      ],
      "metadata": {
        "id": "zl6ulHQAkIDv"
      },
      "execution_count": 61,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#test\n",
        "m=Matrix(2,2)\n",
        "ma=Matrix(2,2)\n",
        "m.setup(2,2)\n",
        "ma.setup(2,2)\n",
        "m.printmatrix()\n",
        "ma.printmatrix()\n",
        "m.shape()\n",
        "m.matrix = [[1, 2, 3], [4, 5, 6]]\n",
        "\n",
        "l= m.scalarmul(2)\n",
        "l.printmatrix()\n",
        "\n",
        "y= m.add(ma)\n",
        "y.printmatrix()\n",
        "\n",
        "z = m.sub(ma)\n",
        "z.printmatrix()\n",
        "\n",
        "gah = m.mat_mult(ma)\n",
        "gah.printmatrix()\n",
        "\n",
        "yikes = (m.element_mult(ma))\n",
        "yikes.printmatrix()\n",
        "\n",
        "yikes2 = m.equals(ma)\n",
        "yikes2.printmatrix()\n",
        "#this doesn't work"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 488
        },
        "id": "2oXBAQXAldl4",
        "outputId": "b21d6284-2f93-4867-f405-f50384f43469"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MATRIX [2] by [2]\n",
            "00\n",
            "00\n",
            "MATRIX [2] by [2]\n",
            "00\n",
            "00\n",
            "MATRIX [2] by [2]\n",
            "24\n",
            "810\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "Matrix.__init__() got an unexpected keyword argument 'matrix'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-71-e0bdc18016a1>\u001b[0m in \u001b[0;36m<cell line: 14>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprintmatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 14\u001b[0;31m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     15\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprintmatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-61-1701e78d4fda>\u001b[0m in \u001b[0;36madd\u001b[0;34m(self, N)\u001b[0m\n\u001b[1;32m     98\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mm\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     99\u001b[0m           \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"nuh uh\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 100\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mMatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmatrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mm\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m#does the same thing but adding\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    101\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    102\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0msub\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: Matrix.__init__() got an unexpected keyword argument 'matrix'"
          ]
        }
      ]
    },
    {
      "source": [
        "class Matrix:\n",
        "    def scalarmul(self, scalar):\n",
        "        result = Matrix(self.rows, self.cols)\n",
        "        for i in range(self.rows):\n",
        "            for j in range(self.cols):\n",
        "                result.matrix[i][j] = self.matrix[i][j] * scalar\n",
        "        return result"
      ],
      "cell_type": "code",
      "metadata": {
        "id": "J04ab8ywmFIc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "A = Matrix(2, 2)\n",
        "A.matrix = [[3, 1], [3, 8]]\n",
        "\n",
        "B = Matrix(2, 2)\n",
        "B.matrix = [[1, 3], [8, 9]]\n",
        "\n",
        "C = Matrix(2, 2)\n",
        "C.matrix = [[8, 2], [2, 7]]\n",
        "\n",
        "#(AB)C = A(BC)\n",
        "print((A * B) * C)\n",
        "print()\n",
        "\n",
        "print(A * (B * C))\n",
        "print()\n",
        "\n",
        "#A(B+C) = AB + AC\n",
        "print(A * (B + C))\n",
        "print()\n",
        "\n",
        "print(A * B + A * C)\n",
        "print()\n",
        "\n",
        "#AB != BA\n",
        "print(A * B)\n",
        "print()\n",
        "\n",
        "print(B * A)\n",
        "print()\n",
        "\n",
        "#AI = A\n",
        "I = Matrix(2, 2)\n",
        "I.matrix = [[1, 0], [0, 1]]\n",
        "\n",
        "print(A * I)\n",
        "print()\n",
        "print(A)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 349
        },
        "id": "uRN-Bc9ynhuB",
        "outputId": "a9a54109-8c46-46e9-a257-c4ec94331ccf"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(AB)C:\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "'Matrix' object has no attribute 'mat_mult'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-75-2448343cd4cc>\u001b[0m in \u001b[0;36m<cell line: 12>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0;31m#(AB)C = A(BC)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"(AB)C:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mB\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mC\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     13\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-73-7c887de9c226>\u001b[0m in \u001b[0;36m__mul__\u001b[0;34m(self, N)\u001b[0m\n\u001b[1;32m     24\u001b[0m     \u001b[0;31m# Matrix multiplication\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__mul__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mN\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmat_mult\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mN\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m     \u001b[0;31m# Element-wise multiplication\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'Matrix' object has no attribute 'mat_mult'"
          ]
        }
      ]
    }
  ]
}