Matrices usando subíndices

Dejó un Aporte sobre esta clase, sobre como pasas de la lógica bidimensional a unidimensional :3

Como me frustro esta clase!! jajaja

Numpy, pandas. Los invoco!

• ¿Te atreves? seguro que sí
  Me atrevo
• No sé cómo hacerlo xD

Al decir “intentar crear una matriz” lo que me imaginé fue algo como

var matrix : [Int][Int];

o

var matrix : [[Int]]

Estaba tan equivocado jajaja

Todo esto me hizo recordar Algebra Lineal de la Universidad! 👨🏼‍💻Creo que todo esto sera interesante para resolver problemas de matematicas con matrices.

Que bonito es lo bonito!!!

//---- Mi aporte,, funciones para sumar y miltiplicar matrices
func sumMatrix (matrixA: Matrix, matrixB: Matrix) -> Matrix{
    var matrixResult = Matrix(rows: matrixA.rows, columns: matrixA.columns)
    if matrixA.columns == matrixB.columns && matrixA.rows == matrixB.rows {
        for row in 0  ..< matrixA.rows {
            for col in 0 ..< matrixB.columns{
                matrixResult [row,col] = matrixA[row,col] + matrixB[row,col]
            }
        }
        
    }else{
        print ("The matrices are not of the same order")
    }
    
    return matrixResult
}

func prodMatrix (matrixA: Matrix, matrixB: Matrix) -> Matrix{
    var matrixResult = Matrix(rows: matrixA.rows, columns: matrixB.columns)
    if matrixA.columns == matrixB.rows {
        for z in 0 ..< matrixA.rows {
            for y in 0 ..< matrixB.columns {
                for x in 0 ..< matrixA.columns{
                    matrixResult[z,y] += (matrixA[z,x] * matrixB[x,y])
                }
            }
        }
    
    }else{
        print("The matrices cannot be multiplied ")
    }
   
    return matrixResult
}

Si deseas evitar iterar sobre la matriz utilizando ciclos anidados y mejorar la legibilidad del código, puedes usar el método joined de los arreglos y el método joined(separator:) de las cadenas para imprimir la matriz de una manera más concisa. Aquí tienes la versión modificada del código:

struct Matrix {
    let rows: Int
    let columns: Int
    var grid: [Double]
    
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(repeating: 0.0, count: rows * columns)
    }
    
    func indexIsValid(row: Int, column: Int) -> Bool {
        return row >= 0 && column >= 0 && row < rows && column < columns
    }
    
    subscript(row: Int, column: Int) -> Double {
        get {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValid(row: row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
    
    func printMatrix() {
        for row in 0..<rows {
            let rowElements = (0..<columns).map { String(self[row, $0]) }
            let rowString = rowElements.joined(separator: " ")
            print(rowString)
        }
    }
}

var matrix = Matrix(rows: 15, columns: 15)
matrix[0, 1] = 1.5
matrix[1, 0] = 2.5
matrix.printMatrix()

Este tipo no sabe explicar. Que estrés

Trabajar con matrices es bien complicado

my matrix

struct Matrix{
    var column = 0
    var row = 0
    var sizeColumns = 2
    var sizeRows = 2
    var elements:[[Int]] = [[]]
    mutating func addElement(_ element:Int){
        
        if(self.column == sizeColumns)
        {
            print("not is posible more thann")
        }
        else
        {
            if(elements[column].count < sizeRows )
            {
                elements[column].append(element)
                
            }
            else
            {
                self.column += 1
                if(self.column < sizeColumns)
                {
                    elements.append([])
                    elements[column].append(element)
                   
                }
                else {
                    print("not is posible more than")
                }
                
               
                
            }
        }
        
    }
}

Yo modifique unas cosas en el código para que al momento de modificar o ver el valor de una “celda” de la matriz, no se haga empezando desde 0 sino desde 1, para las filas y columnas, ya que nosotros cuando queremos en una matriz el primer valor de la primer fila y la primer columna no escribimos [0,0] sino [1,1].

<struct Matrix {
    let rows: Int
    let columns: Int
    var grid: [Double]
    
    init(rows: Int, columns: Int) {
        self.columns = columns
        self.rows = rows
        grid = Array(repeating: 0.0, count: rows * columns)
    }
    
    func indexIsValid(row: Int, column: Int) -> Bool{
        return row >= 0 && column >= 0 && row <= rows && column <= columns
    }
    
    subscript(row: Int,column: Int) -> Double {
        get {
            assert(indexIsValid(row: row, column: column), "Index fuera de rango")
            return grid[((row - 1) * columns) + (column - 1)]
        }
        set {
            assert(indexIsValid(row: row, column: column), "Index fuera de rango")
            grid [((row - 1) * columns) + (column - 1)] = newValue
        }
    }
    
}

var matrix = Matrix(rows: 4, columns: 5)

matrix[1,1] = 5.5
matrix[4,5] = 4.5

for row in 1 ... matrix.rows  {
    for col in 1 ... matrix.columns {
        print(matrix[row, col], separator: "", terminator: " ")
    }
    print(" ")
}>