archive-gh-me/mathjs
1
0
Fork 0
mirror of https://github.com/josdejong/mathjs.git synced 2026-01-25 15:07:57 +00:00
Code Issues Projects Releases Wiki Activity

documentation

Browse Source
This commit is contained in:
rjbaucells 2015-05-04 08:59:05 -04:00
parent 586b93bcf3
commit f40e46a7ce
1 changed files with 120 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

120
lib/type/matrix/util/README.md
View File

@ -0,0 +1,120 @@
Algorithms for the implementation of element wise operations between a Dense and Sparse matrices:
- **Algorithm 1 `x(dense, sparse)`**
* Algorithm should clone `DenseMatrix` and call the `x(d(i,j), s(i,j))` operation for the items in the Dense and Sparse matrices (iterating on the Sparse matrix nonzero items), updating the cloned matrix.
* Output type is a `DenseMatrix` (the cloned matrix)
* `x()` operation invoked NZ times (number of nonzero items in `SparseMatrix`)
**Cij = x(Dij, Sij); Sij != 0**
**Cij = Dij ; otherwise**
_ **Algorithm 2 `x(dense, sparse)`**
* Algorithm should iterate `SparseMatrix` (nonzero items) and call the `x(d(i,j),s(i,j))` operation for the items in the Sparse and Dense matrices (since zero & X == zero)
* Output type is a `SparseMatrix` since the number of nonzero items will be less or equal the number of nonzero elements in the Sparse Matrix.
* `x()` operation invoked NZ times (number of nonzero items in `SparseMatrix`)
**Cij = x(Dij, Sij); Sij != 0**
**Cij = 0 ; otherwise**
- **Algorithm 3 `x(dense, sparse)`**
* Algorithm should iterate `SparseMatrix` (nonzero and zero items) and call the `x(s(i,j),d(i,j))` operation for the items in the Dense and Sparse matrices
* Output type is a `DenseMatrix`
* `x()` operation invoked M*N times
**Cij = x(Dij, Sij); Sij != 0**
**Cij = x(Dij, 0); otherwise**
- **Algorithm 4 `x(sparse, sparse)`**
* Algorithm should iterate on the nonzero values of matrices A and B and call `x(Aij, Bij)` when both matrices contain value at (i,j)
* Output type is a `SparseMatrix`
* `x()` operation invoked NZ times (number of nonzero items at the same (i,j) for both matrices)
**Cij = x(Aij, Bij); Aij != 0 && Bij != 0**
**Cij = Aij; Aij != 0**
**Cij = Bij; Bij != 0**
Algorithms for the implementation of element wise operations between a Sparse matrices:
- **Algorithm 5 `x(sparse, sparse)`**
* Algorithm should iterate on the nonzero values of matrices A and B and call `x(Aij, Bij)` for every nonzero value.
* Output type is a `SparseMatrix`
* `x()` operation invoked NZ times (number of nonzero values in A only + number of nonzero values in B only + number of nonzero values in A and B)
**Cij = x(Aij, Bij); Aij != 0 || Bij != 0**
**Cij = 0; otherwise**
- **Algorithm 6 `x(sparse, sparse)`**
* Algorithm should iterate on the nonzero values of matrices A and B and call `x(Aij, Bij)` when both matrices contain value at (i,j).
* Output type is a `SparseMatrix`
* `x()` operation invoked NZ times (number of nonzero items at the same (i,j) for both matrices)
**Cij = x(Aij, Bij); Aij != 0 && Bij != 0**
**Cij = 0; otherwise**
- **Algorithm 7 `x(sparse, sparse)`**
* Algorithm should iterate on all values of matrices A and B and call `x(Aij, Bij)`
* Output type is a `DenseMatrix`
* `x()` operation invoked MxN times
**Cij = x(Aij, Bij);**
- **Algorithm 8 `x(sparse, sparse)`**
* Algorithm should iterate on the nonzero values of matrices A and B and call `x(Aij, Bij)` when both matrices contain value at (i,j). Use the value from Aij when Bij is zero.
* Output type is a `SparseMatrix`
* `x()` operation invoked NZ times (number of nonzero items at the same (i,j) for both matrices)
**Cij = x(Aij, Bij); Aij != 0 && Bij != 0**
**Cij = Aij; Aij != 0**
**Cij = 0; otherwise**
- **Algorithm 9 `x(sparse, sparse)`**
* Algorithm should iterate on the nonzero values of matrices A `x(Aij, Bij)`.
* Output type is a `SparseMatrix`
* `x()` operation invoked NZA times (number of nonzero items in A)
**Cij = x(Aij, Bij); Aij != 0**
**Cij = 0; otherwise**
Algorithms for the implementation of element wise operations between a Sparse and Scalar Value:
- **Algorithm 10 `x(sparse, scalar)`**
* Algorithm should iterate on the nonzero values of matrix A and call `x(Aij, N)`.
* Output type is a `DenseMatrix`
* `x()` operation invoked NZ times (number of nonzero items)
**Cij = x(Aij, N); Aij != 0**
**Cij = N; otherwise**
- **Algorithm 11 `x(sparse, scalar)`**
* Algorithm should iterate on the nonzero values of matrix A and call `x(Aij, N)`.
* Output type is a `SparseMatrix`
* `x()` operation invoked NZ times (number of nonzero items)
**Cij = x(Aij, N); Aij != 0**
**Cij = 0; otherwise**
- **Algorithm 12 `x(sparse, scalar)`**
* Algorithm should iterate on the zero and nonzero values of matrix A and call `x(Aij, N)`.
* Output type is a `DenseMatrix`
* `x()` operation invoked MxN times.
**Cij = x(Aij, N); Aij != 0**
**Cij = x(0, N); otherwise**
Algorithms for the implementation of element wise operations between a Dense and Dense matrices:
- **Algorithm 13 `x(dense, dense)`
* Algorithm should iterate on the values of matrix A and B for all dimensions and call `x(Aij..z,Bij..z)`
* Output type is a `DenseMatrix`
* `x()` operation invoked Z times, where Z is the number of elements in the matrix last dimension. For two dimensional matrix Z = MxN
**Cij..z = x(Aij..z, Bij..z)**
Algorithms for the implementation of element wise operations between a Dense Matrix and a Scalar Value.
- **Algorithm 14 `x(dense, scalar)`**
* Algorithm should iterate on the values of matrix A for all dimensions and call `x(Aij..z, N)`
* Output type is a `DenseMatrix`
* `x()` operation invoked Z times, where Z is the number of elements in the matrix last dimension.
**Cij..z = x(Aij..z, N)**