// Created for this challenge: // https://www.sololearn.com/post/35155 // Define a Generic Matrix Class. It should // provide support for a Class, Floating Point, // Integer, and String data. Provide all of the // following operations as will work for the // instantiated data type: // - Add a second matrix instance to the instance, // - Add a constant to all elements of the instance, // - Concatenate a second matrix strings to the // instance, // - Create a new sub-matrix instance of a range, // - Divide a second matrix instance into the // instance, // - Divide a constant into all elements of the // instance, // - Multiply a second matrix instance with the // instance, // - Multiply a constant with all elements of the // instance, // - Sort all rows or columns by their column or row // values, // - Subtract a second matrix instance from the // instance, // - Subtract a constant from all elements of the // instance, and // - Transpose the matrix instance. // You should use callbacks to provide the type // dependent operations. Null callbacks states the // operation isn't available for the type. You could // provide operator overloading, if your language // supports it. You need to prove each operation // works from your main program and demonstrate it is // a valid generic by using an instance of all four // types for some of the operations. // Play with operator overload. Define all reasonable // operators for dealing with an integer. All // math functions must return a new instance. Note: // each function can be called by name or via // operator. Used here to test Matrix with a class. class Demo(val value: Int) { // +demo operator fun unaryPlus() = Demo(+value) // -demo operator fun unaryMinus() = Demo(-value) // ++demo or demo++ operator fun inc() = Demo(value+1) // --demo or demo-- operator fun dec() = Demo(value-1) // demo+operand operator fun plus(operand: Demo) = Demo(value+operand.value) operator fun plus(operand: Int) = Demo(value+operand) // demo-operand operator fun minus(operand: Demo) = Demo(value-operand.value) operator fun minus(operand: Int) = Demo(value-operand) // demo*operand operator fun times(operand: Demo) = Demo(value*operand.value) operator fun times(operand: Int) = Demo(value*operand) // demo%operand operator fun rem(operand: Demo) = Demo(value%operand.value) operator fun rem(operand: Int) = Demo(value%operand) // demo/operand operator fun div(operand: Demo) = Demo(value/operand.value) operator fun div(operand: Int) = Demo(value/operand) // demo == operand (!= < > <= >=) returning // -1, 0, 1 base on the comparison. operator fun compareTo(operand: Demo) = when { value < operand.value -> -1 value == operand.value -> 0 else -> 1 } // when // Override the default to just return the integer. override fun toString() = "$value" // Allow conversion to integer. fun toInt() = value } // Demo // Exception for trying to perform an operation // that doesn't have a callback available to // execute. class OperationUnavailableException( message: String) : Exception(message) // Exception for trying to perform an operation // with two matrices that have different size. class MatrixSizeException( message: String) : Exception(message) // Exception for trying to perform a slice operation // with a range outside of the matrix. class RangeException( message: String) : Exception(message) // An enumeration for the operation we want the // math callback to perform. enum class Operation { Add, Divide, Multiply, Subtract } // Operation // Data class to hold the actual element as we // can't make an array out of a template type // because of the hidden information. data class Element(var value: T) // A generic matrix class to support the challenge // requirements. Created with a set of seven values. class Matrix( // Initialize the class with these values: the // number of rows & columns in our matrix and // a list of elements to store into our matrix // once we allocate it. private val rows: Int, private val columns: Int, list: List, // Initialize the class with these callbacks. // The callbacks required to process the // template type. The first is required to // compare the elements and return their // relationship to each other used to sort the // elements. The remaining ones are optional // defaulting to null. The callback to perform // math operations, the callback to make a copy // of the element so modifying one leaves the // other untouched, and the callback to // concatenate two strings. private val comparing: (T, T) -> Int, private val math: (( Operation, T, T) -> T)? = null, private val cloning: ((T) -> T)? = null, private val concatenating: (( T, T) -> T)? = null) { // Allocate and initialize the matrix data with the // values in the list. If the list is short, reuse // the list from the beginning when it runs out. private val data = Array(rows) { row -> Array(columns) { Element(list[(row*columns+it)% list.size]) } // Array } // data // Method to add a single element value to all // elements of the matrix. Called with the element. fun add(value: T) { // If there is not a concatenation callback, // hopefully we got a math callback. val concatenate = concatenating if (concatenate == null) { // If there is not a math callback, throw an // exception as the operation can not be done. val op = math if (op == null) throw OperationUnavailableException( "Add is not available!") // Otherwise, we have a callback we can use so // for each element in the matrix have the // callback deal with the two elements and // put the result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op(Operation.Add, data[row][column].value, value) // Otherwise, we are going to concatenate two // strings. For each element in the matrix // have the callback deal with the two strings // and put the result back. } else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = concatenate( data[row][column].value, value) } // add // Method to add the elements of the parameter // matrix to all the corresponding elements of the // matrix. Called with the second matrix. fun add(matrix: Matrix) { // If there is not a concatenation callback, // hopefully we got a math callback. val concatenate = concatenating if (concatenate == null) { // If there is not a math callback, throw an // exception as the operation can not be done. val op = math if (op == null) throw OperationUnavailableException( "Add is not available!") // Otherwise, if the size of the matrix we want // to add is not the same as the matrix we are // trying to add it to, throw an exception as // we don't support it. else if (rows != matrix.rows || columns != matrix.columns) throw MatrixSizeException( "Difference in size of matrices!") // Otherwise, we have a callback we can use and // the matrices are the same size so for each // element in the matrices have the callback // deal with the two elements and put the // result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op(Operation.Add, data[row][column].value, matrix.data[row][column].value) // Otherwise, we are going to concatenate two // strings. For each element in the matrices // have the callback deal with the two strings // and put the result back. } else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = concatenate( data[row][column].value, matrix.data[row][column].value) } // add // Method to clone the class. Make a list of the // existing elements cloning them if there is a // callback for it. Allocate the new matrix with // the list and the values we got created with. fun clone(): Matrix { val list = List(rows*columns) { val op = cloning if (op == null) data[it/columns][it%columns].value else op(data[it/columns][it%columns].value) } // list return Matrix(rows, columns, list, comparing, math, cloning, concatenating) } // clone // Method to concatenate a single element value to // all elements of the matrix. Called with the // element. fun concatenate(value: T) { // If there is not a concatenation callback, // throw an exception as the operation can not // be done. val op = concatenating if (op == null) throw OperationUnavailableException( "Concatenate is not available!") // Otherwise, we are going to concatenate two // strings. For each element in the matrix // have the callback deal with the two elements // and put the result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op( data[row][column].value, value) } // concatenate // Method to concatenate the elements of the // parameter matrix to all elements of the matrix. // Called with the second matrix. fun concatenate(matrix: Matrix) { // If there is not a concatenation callback, // throw an exception as the operation can not // be done. val op = concatenating if (op == null) throw OperationUnavailableException( "Concatenate is not available!") // Otherwise, if the size of the matrix we want // to concatenate is not the same as the matrix // we are trying to concatenate it to, throw an // exception as we don't support it. else if (rows != matrix.rows || columns != matrix.columns) throw MatrixSizeException( "Difference in size of matrices!") // Otherwise, we are going to concatenate two // strings. For each element in the matrices // have the callback deal with the two strings // and put the result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op( data[row][column].value, matrix.data[row][column].value) } // concatenate // Method to display each element in the matrix. fun display() { for (row in data) { for (value in row) print("${value.value} ") println() } // for } // display // Operator overload method to handle the divide // operator with a single element to be divided // into the entire matrix. Clone the matrix as // operators always make new instances. Perform // the divide on the new instance and return it. operator fun div(operand: T): Matrix { val matrix = clone() matrix.divide(operand) return matrix } // div // Operator overload method to handle the divide // operator with a matrix to be divided into our // matrix. Clone the matrix as operators always // make new instances. Perform the divide on the // new instance and return it. operator fun div(operand: Matrix): Matrix { val matrix = clone() matrix.divide(operand) return matrix } // div // Method to divide a single element value into all // elements of the matrix. Called with the element. fun divide(value: T) { // If there is not a math callback, throw an // exception as the operation can not be done. val op = math if (op == null) throw OperationUnavailableException( "Divide is not available!") // Otherwise, we have a callback we can use so // for each element in the matrix have the // callback deal with the two elements and // put the result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op(Operation.Divide, data[row][column].value, value) } // divide // Method to divide the elements of the parameter // matrix into all the corresponding elements of // the matrix. Called with the second matrix. fun divide(matrix: Matrix) { // If there is not a math callback, throw an // exception as the operation can not be done. val op = math if (op == null) throw OperationUnavailableException( "Divide is not available!") // Otherwise, if the size of the matrix we want // to divide by is not the same as the matrix we // are trying to divide, throw an exception as // we don't support it. else if (rows != matrix.rows || columns != matrix.columns) throw MatrixSizeException( "Difference in size of matrices!") // Otherwise, we have a callback we can use and // the matrices are the same size so for each // element in the matrices have the callback // deal with the two elements and put the // result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op(Operation.Divide, data[row][column].value, matrix.data[row][column].value) } // divide // Operator overload method to handle the subtract // operator with a single element to be subtracted // into the entire matrix. Clone the matrix as // operators always make new instances. Perform // the subtract on the new instance and return it. operator fun minus(operand: T): Matrix { val matrix = clone() matrix.subtract(operand) return matrix } // minus // Operator overload method to handle the subtract // operator with a matrix to be subtracted into our // matrix. Clone the matrix as operators always // make new instances. Perform the subtract on the // new instance and return it. operator fun minus(operand: Matrix): Matrix { val matrix = clone() matrix.subtract(operand) return matrix } // minus // Method to multiply a single element value into // all elements of the matrix. Called with the // element. fun multiply(value: T) { // If there is not a math callback, throw an // exception as the operation can not be done. val op = math if (op == null) throw OperationUnavailableException( "Multiply is not available!") // Otherwise, we have a callback we can use so // for each element in the matrix have the // callback deal with the two elements and // put the result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op(Operation.Multiply, data[row][column].value, value) } // multiply // Method to multiply the elements of the parameter // matrix into all the corresponding elements of // the matrix. Called with the second matrix. fun multiply(matrix: Matrix) { // If there is not a math callback, throw an // exception as the operation can not be done. val op = math if (op == null) throw OperationUnavailableException( "Multiply is not available!") // Otherwise, if the size of the matrix we want // to multiply by is not the same as the matrix // we are trying to multiply, throw an exception // as we don't support it. else if (rows != matrix.rows || columns != matrix.columns) throw MatrixSizeException( "Difference in size of matrices!") // Otherwise, we have a callback we can use and // the matrices are the same size so for each // element in the matrices have the callback // deal with the two elements and put the // result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op(Operation.Multiply, data[row][column].value, matrix.data[row][column].value) } // multiply // Operator overload method to handle the add // operator with a single element to be added // into the entire matrix. Clone the matrix as // operators always make new instances. Perform // the add on the new instance and return it. operator fun plus(operand: T): Matrix { val matrix = clone() matrix.add(operand) return matrix } // plus // Operator overload method to handle the add // operator with a matrix to be added into our // matrix. Clone the matrix as operators always // make new instances. Perform the add on the // new instance and return it. operator fun plus(operand: Matrix): Matrix { val matrix = clone() matrix.add(operand) return matrix } // plus // Method to create a sub-matrix slice of the // original. Called with the range of rows and // the range of columns. fun slice(row: IntRange, column: IntRange): Matrix { // If the ranges starts before or ends after the // valid values for our matrix, throw an // exception stating the ranges are invalid. if (row.first < 0 || row.last >= rows || column.first < 0 || column.last >= columns) throw RangeException("Slice invalid range!") // Otherwise, we can make the sub-matrix so // grab the size of the new matrix rows & // columns, make a list of the elements we are // using cloning them as required, and return // the newly created matrix. else { val rowSize = row.last-row.first+1 val columnSize = column.last-column.first+1 val list = List(rowSize*columnSize) { val op = cloning if (op == null) data[it/columnSize+row.first][ it%columnSize+column.first].value else op(data[it/columnSize+row.first][ it%columnSize+column.first].value) } // list return Matrix(rowSize, columnSize, list, comparing, math, cloning, concatenating) } } // slice // Method to transpose the matrix into a new one. // Make a list of the elements reorganized for the // the matrix and return the new instance. fun transpose(): Matrix { val list = List(rows*columns) { val op = cloning if (op == null) data[it%rows][it/rows].value else op(data[it%rows][it/rows].value) } // list return Matrix(columns, rows, list, comparing, math, cloning, concatenating) } // transpose // Method to sort the matrix. Called with the // row number or a the negative of the column // number to perform the sort on. Do the sort // on the rows of the matrix with the comparison // of the elements in the column so a row sort // needs to be transposed before sorting. fun sort(index: Int) { // Get the actual index to sort with and make // a lambda to use for the sort that gets to // the elements to compare and uses the callback // to do so. var position = -index-1 val comparator = { p1: Array>, p2: Array> -> comparing(p1[position].value, p2[position].value) } // comparator // If we are sorting by a column and it is in // range, the matrix is ready to go so sort it. if (-index in 1..columns) data.sortWith(Comparator(comparator)) // Otherwise, we should have a row so, if it is // in range, the matrix must be transposed, // update the actual index to sort with, sort the // transposed matrix, and update all of the // elements of the original with the values of // the sorted matrix. else if (index in 1..rows) { val matrix = transpose() position = index-1 matrix.data.sortWith(Comparator(comparator)) (0 until rows).map { r -> (0 until columns).map { data[r][it].value = matrix.data[it][r].value } // map } // map } // if } // sort // Method to subtract a single element value to all // elements of the matrix. Called with the element. fun subtract(value: T) { // If there is not a math callback, throw an // exception as the operation can not be done. val op = math if (op == null) throw OperationUnavailableException( "Subtract is not available!") // Otherwise, we have a callback we can use so // for each element in the matrix have the // callback deal with the two elements and // put the result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op(Operation.Subtract, data[row][column].value, value) } // subtract // Method to subtract the elements of the parameter // matrix from all the corresponding elements of // the matrix. Called with the second matrix. fun subtract(matrix: Matrix) { // If there is not a math callback, throw an // exception as the operation can not be done. val op = math if (op == null) throw OperationUnavailableException( "Subtract is not available!") // Otherwise, if the size of the matrix we want // to add is not the same as the matrix we are // trying to add it to, throw an exception as // we don't support it. else if (rows != matrix.rows || columns != matrix.columns) throw MatrixSizeException( "Difference in size of matrices!") // Otherwise, we have a callback we can use and // the matrices are the same size so for each // element in the matrices have the callback // deal with the two elements and put the // result back. else for (row in 0 until rows) for (column in 0 until columns) data[row][column].value = op(Operation.Subtract, data[row][column].value, matrix.data[row][column].value) } // subtract // Operator overload method to handle the multiply // operator with a single element to be multiplied // into the entire matrix. Clone the matrix as // operators always make new instances. Perform // the multiply on the new instance and return it. operator fun times(operand: T): Matrix { val matrix = clone() matrix.multiply(operand) return matrix } // times // Operator overload method to handle the multiply // operator with a matrix to be multiplied into our // matrix. Clone the matrix as operators always // make new instances. Perform the multiply on the // new instance and return it. operator fun times(operand: Matrix): Matrix { val matrix = clone() matrix.multiply(operand) return matrix } // times } // Matrix // Function to test the Matrix class with a class // element. Make use of our operator overload Demo // class as it was already coded to have all the // operations we might want. Test the subtraction // and sort operations. fun testClass() { // Make lambda functions for our callbacks to // compare two elements, perform all supported // math operations, and cloning our class so // an instance won't end up being shared between // two instances of the Matrix class. val comparing = { p1: Demo, p2: Demo -> p1.compareTo(p2) } // comparing val math = { op: Operation, p1: Demo, p2: Demo -> when (op) { Operation.Add -> p1+p2 Operation.Divide -> p1/p2 Operation.Multiply -> p1*p2 Operation.Subtract -> p1-p2 } // when } // math val cloning = { element: Demo -> Demo(element.value) } // cloning // Allocate an instance of the Matrix with a 2x2 // matrix. Display the original, sort it by the // second column, and display the result. val matrix1 = Matrix(2, 2, listOf(Demo(7), Demo(6), Demo(1), Demo(3)), comparing, math, cloning) println("\nFirst Demo class 2x2 matrix:") matrix1.display() matrix1.sort(-2) println("\nSorted by second column:") matrix1.display() // Allocate an second instance of the 2x2 matrix // by subtracting one from the first matrix, // display the result, subtract the first matrix // from the second, and display the final result. var matrix2 = matrix1-Demo(1) println("\nSecond Demo class 2x2 matrix "+ "(subtracting 1):") matrix2.display() matrix2 -= matrix1 println("\nSubtracting first from second:") matrix2.display() } // testClass // Function to test the Matrix class with a double // element. Test the multiplication, division, and // sub-matrix creation operations. fun testFloat() { // Make lambda functions for our callbacks to // compare two elements and perform all supported // math operations. val comparing = { p1: Double, p2: Double -> p1.compareTo(p2) } // comparing val math = { op: Operation, p1: Double, p2: Double -> when (op) { Operation.Add -> p1+p2 Operation.Divide -> p1/p2 Operation.Multiply -> p1*p2 Operation.Subtract -> p1-p2 } // when } // math // Allocate an instance of the Matrix with a 3x3 // matrix. Display the original, allocate an second // instance of the 3x3 matrix by multiplying the // first matrix by two, display the result, // multiply the second matrix by the first, and // display the final result. val matrix1 = Matrix(3, 3, listOf(7.0, 6.0, 5.0, 1.0, 2.0, 3.0, 4.0, 8.0, 9.0), comparing, math) println("\nFirst Double 3x3 matrix:") matrix1.display() var matrix2 = matrix1*2.0 println("\nSecond Double 3x3 matrix "+ "(multiplying by 2):") matrix2.display() matrix2 *= matrix1 println("\nMultiplying second by first:") matrix2.display() // Divide the second matrix by two, display the // result, divide the second matrix by the first, // and display the final result. matrix2 /= 2.0 println("\nDividing second by 2:") matrix2.display() matrix2 /= matrix1 println("\nDivide second by first:") matrix2.display() // Create a sub-matrix of the first matrix to // replace the second matrix with and display the // results. matrix2 = matrix1.slice(0..1, 1..2) println("\nSlice a 2x2 from first:") matrix2.display() } // testFloat // Function to test the Matrix class with an integer // element. Test the addition, sort, and transpose // operations. fun testInt() { // Make lambda functions for our callbacks to // compare two elements and perform all supported // math operations. val comparing = { p1: Int, p2: Int -> p1.compareTo(p2) } // comparing val math = { op: Operation, p1: Int, p2: Int -> when (op) { Operation.Add -> p1+p2 Operation.Divide -> p1/p2 Operation.Multiply -> p1*p2 Operation.Subtract -> p1-p2 } // when } // math // Allocate an instance of the Matrix with a 2x3 // matrix. Display the original, sort it by the // second column, display the result, sort it by // the second row, and display the final result. val matrix1 = Matrix(2, 3, listOf(4, 2, 5, 6, 1, 3), comparing, math) println("\nFirst integer 2x3 matrix:") matrix1.display() matrix1.sort(-2) println("\nSorted by second column:") matrix1.display() matrix1.sort(2) println("\nSorted by second row:") matrix1.display() // Allocate an second instance of the 2x3 matrix // by adding three to the first matrix, display the // result, add the first matrix to the second, and // display the final result. var matrix2 = matrix1+3 println("\nSecond integer 2x3 matrix (adding 3):") matrix2.display() matrix2 += matrix1 println("\nAdding first to second:") matrix2.display() // Create a transposed version of the second matrix // to replace it with and display the results. matrix2 = matrix2.transpose() println("\nTransposed second:") matrix2.display() } // testInt // Function to test the Matrix class with a string // element. Test the concatenation operations. fun testString() { // Make lambda functions for our callbacks to // compare two elements and perform the // concatenation. val comparing = { p1: String, p2: String -> p1.compareTo(p2) } // comparing val concatenate = { p1: String, p2: String -> p1+p2 } // concatenate // Allocate an instance of the Matrix with a 2x2 // matrix. Display the original, allocate a second // by concatenating an explanation point to the // first, display the result, concatenate the // first matrix to the second, and display the // final matrix. val matrix1 = Matrix(2, 2, listOf("One", "Two", "Three", "Four"), comparing, null, null, concatenate) println("\nFirst String 2x2 matrix:") matrix1.display() var matrix2 = matrix1+"!" println("\nSecond String 2x2 matrix (adding !):") matrix2.display() matrix2 += matrix1 println("\nAdding first to second:") matrix2.display() } // testString // Main entry point function to test the Matrix // class by calling the individual test functions. fun main(args: Array) { testClass() testFloat() testInt() testString() } // main

genericMatrix ch oo