hey im working on a project for someone.

and i have no idea where to begin. i know im suppose to implement matrix functions on this code if someone could help me that would be nice

# Working on a project need help

```
import math
from math import sqrt
import numbers
def zeroes(height, width):
"""
Creates a matrix of zeroes.
"""
g = [[0.0 for _ in range(width)] for __ in range(height)]
return Matrix(g)
def identity(n):
"""
Creates a n x n identity matrix.
"""
I = zeroes(n, n)
for i in range(n):
I.g[i][i] = 1.0
return I
class Matrix(object):
# Constructor
def __init__(self, grid):
self.g = grid
self.h = len(grid)
self.w = len(grid[0])
#
# Primary matrix math methods
#############################
def determinant(self):
"""
Calculates the determinant of a 1x1 or 2x2 matrix.
"""
if not self.is_square():
raise(ValueError, "Cannot calculate determinant of non-square matrix.")
if self.h > 2:
raise(NotImplementedError, "Calculating determinant not implemented for matrices largerer than 2x2.")
# TODO - your code here
def trace(self):
"""
Calculates the trace of a matrix (sum of diagonal entries).
"""
if not self.is_square():
raise(ValueError, "Cannot calculate the trace of a non-square matrix.")
# TODO - your code here
def inverse(self):
"""
Calculates the inverse of a 1x1 or 2x2 Matrix.
"""
if not self.is_square():
raise(ValueError, "Non-square Matrix does not have an inverse.")
if self.h > 2:
raise(NotImplementedError, "inversion not implemented for matrices larger than 2x2.")
# TODO - your code here
def T(self):
"""
Returns a transposed copy of this Matrix.
"""
# TODO - your code here
def is_square(self):
return self.h == self.w
#
# Begin Operator Overloading
############################
def __getitem__(self,idx):
"""
Defines the behavior of using square brackets [] on instances
of this class.
Example:
> my_matrix = Matrix([ [1, 2], [3, 4] ])
> my_matrix[0]
[1, 2]
> my_matrix[0][0]
1
"""
return self.g[idx]
def __repr__(self):
"""
Defines the behavior of calling print on an instance of this class.
"""
s = ""
for row in self.g:
s += " ".join(["{} ".format(x) for x in row])
s += "\n"
return s
def __add__(self,other):
"""
Defines the behavior of the + operator
"""
if self.h != other.h or self.w != other.w:
raise(ValueError, "Matrices can only be added if the dimensions are the same")
#
# TODO - your code here
#
def __neg__(self):
"""
Defines the behavior of - operator (NOT subtraction)
Example:
> my_matrix = Matrix([ [1, 2], [3, 4] ])
> negative = -my_matrix
> print(negative)
-1.0 -2.0
-3.0 -4.0
"""
#
# TODO - your code here
#
def __sub__(self, other):
"""
Defines the behavior of - operator (as subtraction)
"""
#
# TODO - your code here
#
def __mul__(self, other):
"""
Defines the behavior of * operator (matrix multiplication)
"""
#
# TODO - your code here
#
def __rmul__(self, other):
"""
Called when the thing on the left of the * is not a matrix.
Example:
> identity = Matrix([ [1,0], [0,1] ])
> doubled = 2 * identity
> print(doubled)
2.0 0.0
0.0 2.0
"""
if isinstance(other, numbers.Number):
pass
#
# TODO - your code here
#
```

**mtf**#3

That line may be removed since you have the math module already imported. But, if all want from the math module is the sqrt function, then remove the previous line. One or the other, but not both.

Let me see if I’ve got this straight… You are doing this *for someone*, and wish for us to do it, *for you*. Does that mean *we*, and *not you*, are doing this *for that someone*?

**system**#4

This topic was automatically closed 7 days after the last reply. New replies are no longer allowed.