SassyMatrix 1.0.0

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+* `1.0.11`: fixing an issue with scientific number parsing
+* `1.0.10`: improving number and string helpers
+* `1.0.9`: fixing a bug in `_find-exponent`
+* `1.0.8`: fixing a major issue in Ruby Gem
+* `1.0.7`: minor fixes and stable Ruby Gem
+* `1.0.6`: released a Ruby Gem
+* `1.0.5`: improved the encoding mixin
+* `1.0.4`: fixed an error in map parsing
+* `1.0.3`: slightly edited the mixin to dump JSON to CSS
+* `1.0.2`: fixed an issue with string parsing
+* `1.0.1`: fixed an issue with alpha color parsing
+* `1.0.0`: Stable API. `json-encode` and `json-decode`
+* `0.0.2`: added `json-decode` and test
+* `0.0.1`: initial commit

data/README.md

@@ -0,0 +1,61 @@
+# SassyMatrix [![Build Status](https://travis-ci.org/HugoGiraudel/SassyMatrix.png)](https://travis-ci.org/HugoGiraudel/SassyMatrix)
+
+All you ever wanted to deal with matrices in Sass.
+
+## What's in there?
+
+### Instanciating matrix
+* `matrix($x, $y: $x)`: create a matrix of `$x` rows by `$y` columns filled with 0s
+* `unit-matrix($x, $y)`: create a matrix of `$x` rows by `$y` columns filled with 0s except the diagonal which is filled with 1s
+
+### Writing in matrix
+* `set-entry($matrix, $coords, $value)`: set `$value` at `$matrix[$coords[1], $coords[2]]`
+* `set-column($matrix, $index, $column: ())`: set `$column` at `$index` in `$matrix`
+* `set-row($matrix, $index, $row: ())`: set `$row` at `$index` in `$matrix`
+* `add-column($matrix, $column: (), $index: null)`: add `$column` at `$index` in `$matrix`
+* `add-row($matrix, $row: (), $index: null)`: add `$row` at `$index` in `$matrix`
+
+### Reading matrix
+* `get-entry($matrix, $coords)`: get entry at `$matrix[$coords[1], $coords[2]]`
+* `get-column($matrix, $index)`: get column at `$index` from `$matrix`
+* `get-row($matrix, $index)`: get row at `$index` from `$matrix`
+
+### Displaying matrix
+* `display($matrix)`: display matrix
+
+### Altering matrix
+* `swap-entries($matrix, $e1, $e2)`: swaps values `$e1` and `$e2` from `$matrix`
+* `swap-rows($matrix, $r1, $r2)`: swaps rows `$r1` and `$r2` from `$matrix`
+* `swap-columns($matrix, $c1, $c2)`: swaps columns `$c1` and `$c2` from `$matrix`
+* `transpose($matrix)`: rotates `$matrix` around its diagonal
+* `add-matrices($matrix1, $matrix2)`: add `$matrix1` and `$matrix2`
+
+### Checking for matrix properties
+* `columns($matrix)`: return number of columns in `$matrix`
+* `rows($matrix)`: return number of rows in `$matrix`
+* `is-numeric($matrix)`: check whether `$matrix` has only numeric values
+* `is-square($matrix)`: check whether `$matrix` has as many rows as columns
+* `is-diagonal($matrix)`: check whether all values from the main diagonal of `$matrix` are set while all other values are equal to 0
+* `is-lower-triangular($matrix, $flag: null)`: check whether all value below `$matrix` diagonal are equal to 0
+* `is-upper-triangular($matrix, $flag: null)`: check whether all value above `$matrix` diagonal are equal to 0
+
+## Requirements
+
+All you need is a clean version of Sass 3.3. Otherwise it's just pure Sass madness.
+
+## Development
+
+### You need
+
+  * [NodeJS](http://nodejs.org)
+  * [Ruby](https://www.ruby-lang.org/)
+  * Sass 3.3 via `gem instal sass --pre`
+  * `grunt-cli` via `npm install -g grunt-cli`
+
+### How to
+
+  1. Fork this repository
+  2. Run `npm install`
+  3. `grunt dev`
+  4. Make your changes + write tests
+  5. Commit + Pull request

data/lib/SassyMatrix.rb

@@ -0,0 +1,14 @@
+require 'compass'
+extension_path = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+Compass::Frameworks.register('SassyJSON', :path => extension_path)
+
+#  Version is a number. If a version contains alphas, it will be created as a prerelease version
+#  Date is in the form of YYYY-MM-DD
+module SassyMatrix
+  VERSION = "1.0.0"
+  DATE = "2014-01-23"
+end
+
+module Sass::Script::Functions
+
+end

data/stylesheets/functions/checkers/_is-diagonal.scss

@@ -0,0 +1,22 @@
+// Checks whether all entries from the main diagonal of `$matrix`
+// are set while all other entries are equal to the 0
+// --------------------------------------------------------------------------------
+// @require `get-entry`
+// @require `columns`
+// @require `rows`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// --------------------------------------------------------------------------------
+// @return boolean
+
+@function is-diagonal($matrix) {
+  @for $i from 1 through rows($matrix) {
+    @for $j from 1 through columns($matrix) {
+      $entry: get-entry($matrix, ($i $j));
+      @if ($i != $j and $entry != 0) or ($i == $j and $entry == 0) {
+        @return false;
+      }
+    }
+  }
+  @return true;
+}

data/stylesheets/functions/checkers/_is-lower-triangular.scss

@@ -0,0 +1,12 @@
+// Checks whether `$matrix` is lower triangular with `$flag` option
+// --------------------------------------------------------------------------------
+// @require `_is-triangular`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $flag: advanced option (null | strict | unit | atom)
+// --------------------------------------------------------------------------------
+// @return boolean
+
+@function is-lower-triangular($matrix, $flag: null) {
+  @return _is-triangular($matrix, bottom, $flag);
+}

data/stylesheets/functions/checkers/_is-numeric.scss

@@ -0,0 +1,18 @@
+// Checks whether all entries from `$matrix` are numeric
+// --------------------------------------------------------------------------------
+// @require `rows`
+// @require `columns`
+// @require `get-entry`
+// --------------------------------------------------------------------------------
+// @return boolean
+
+@function is-numeric($matrix) {
+  @for $i from 1 through rows($matrix) {
+    @for $j from 1 through columns($matrix) {
+      @if type-of(get-entry($matrix, ($i $j))) != number {
+        @return false;
+      }
+    }
+  }
+  @return true;
+}

data/stylesheets/functions/checkers/_is-square.scss

@@ -0,0 +1,12 @@
+// Returns whether `$matrix` has as many rows as columns
+// --------------------------------------------------------------------------------
+// @require `columns`
+// @require `rows`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// --------------------------------------------------------------------------------
+// @return boolean
+
+@function is-square($matrix) {
+  @return columns($matrix) == rows($matrix);
+}

data/stylesheets/functions/checkers/_is-symmetric.scss

@@ -0,0 +1,15 @@
+// Checks whether a matrix is symetric
+// --------------------------------------------------------------------------------
+// @require `transpose`
+// @require `is-square`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// --------------------------------------------------------------------------------
+// @return boolean
+
+@function is-symmetric($matrix) {
+  @if not is-square($matrix) {
+    @return false;
+  }
+  @return $matrix == transpose($matrix);
+}

data/stylesheets/functions/checkers/_is-upper-triangular.scss

@@ -0,0 +1,12 @@
+// Checks whether `$matrix` is upper triangular with `$flag` option
+// --------------------------------------------------------------------------------
+// @require `_is-triangular`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $flag: advanced option (null | strict | unit | atom)
+// --------------------------------------------------------------------------------
+// @return boolean
+
+@function is-upper-triangular($matrix, $flag: null) {
+  @return _is-triangular($matrix, top, $flag);
+}

data/stylesheets/functions/getters/_get-column.scss

@@ -0,0 +1,29 @@
+// Return column at `$index` from `$matrix`
+// --------------------------------------------------------------------------------
+// @require `get-entry`
+// @require `rows`
+// @require `columns`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $index: index
+// --------------------------------------------------------------------------------
+// @return list
+
+@function get-column($matrix, $index) {
+  @if type-of($index) != number {
+    @warn "Invalid column index.";
+    @return false;
+  }
+
+  @if abs($index) > columns($matrix) {
+    @warn "Out of bound column index.";
+    @return false;
+  }
+
+  $column: ();
+  @for $i from 1 through rows($matrix) {
+    $column: append($column, get-entry($matrix, ($i $index)))
+  }
+
+  @return $column;
+}

data/stylesheets/functions/getters/_get-entry.scss

@@ -0,0 +1,20 @@
+// Returns entry at `$matrix[$coords[1], $coords[2]]`
+// --------------------------------------------------------------------------------
+// @require `_valid-coords`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $coords: (x y) coordinates
+// --------------------------------------------------------------------------------
+// @return literal
+
+@function get-entry($matrix, $coords) {
+  @if length($coords) == 1 {
+    $coords: ($coords $coords);
+  }
+
+  @if _valid-coords($coords, $matrix) {
+    @return nth(nth($matrix, nth($coords, 1)), nth($coords, 2));
+  }
+
+  @return false;
+}

data/stylesheets/functions/getters/_get-row.scss

@@ -0,0 +1,22 @@
+// Return row at `$index` from `$matrix`
+// --------------------------------------------------------------------------------
+// @require `rows`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $index: index
+// --------------------------------------------------------------------------------
+// @return list
+
+@function get-row($matrix, $index) {
+  @if type-of($index) != number {
+    @warn "Invalid row index.";
+    @return false;
+  }
+
+  @if abs($index) > rows($matrix) {
+    @warn "Out of bound row index.";
+    @return false;
+  }
+
+  @return nth($matrix, $index);
+}

data/stylesheets/functions/helpers/_is-triangular.scss

@@ -0,0 +1,30 @@
+// Checks whether `$matrix` is `$side` triangular with `$flag` options
+// --------------------------------------------------------------------------------
+// @require `rows`
+// @require `columns`
+// @require `get-entry`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $side: side (top | bottom)
+// @param $flag: advanced options (null | strict | unit | atom)
+// --------------------------------------------------------------------------------
+// @return boolean
+
+@function _is-triangular($matrix, $side: top, $flag: null) {
+  @for $i from 1 through rows($matrix) {
+    @for $j from 1 through columns($matrix) {
+      $entry: get-entry($matrix, ($i $j));
+      @if $i > $j {
+        @if $side == top and $entry != 0 { @return false; }
+      }
+      @else if $i < $j {
+        @if $side == bottom and $entry != 0 { @return false; }
+      }
+      @else {
+        @if $flag == strict and $entry != 0 { @return false; }
+        @if $flag == unit and $entry != 1 { @return false; }
+      }
+    }
+  }
+  @return true;
+}

data/stylesheets/functions/helpers/_valid-coords.scss

@@ -0,0 +1,37 @@
+// Checks whether `$coords` are valid coordinates
+// --------------------------------------------------------------------------------
+// @require `rows`
+// @require `columns`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $coords: coordinates
+// --------------------------------------------------------------------------------
+// @return boolean
+
+@function _valid-coords($coords, $matrix: null) {
+  @if length($coords) == 1 {
+    $coords: ($coords, $coords);
+  }
+
+  $x: nth($coords, 1);
+  $y: nth($coords, 2);
+
+  @if length($coords) != 2 {
+    @warn "Wrong number of coordinates.";
+    @return false;
+  }
+
+  @if type-of($x) != number or type-of($y) != number {
+    @warn "Invalid coordinates.";
+    @return false;
+  }
+
+  @if $matrix {
+    @if abs($x) > rows($matrix) or abs($y) > columns($matrix) {
+      @warn "Out of bound coordinates.";
+      @return false;
+    }
+  }
+
+  @return true;
+}

data/stylesheets/functions/init/_matrix.scss

@@ -0,0 +1,23 @@
+// Initializing a matrix of `$x` by `$y` with 0s
+// --------------------------------------------------------------------------------
+// @require `_valid-coords`
+// --------------------------------------------------------------------------------
+// @param $x: number of rows
+// @param $y: number of columns
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function matrix($x, $y: $x) {
+  @if _valid-coords(($x $y)) {
+    $matrix: ();
+    @for $i from 1 through $x {
+      $tmp: ();
+      @for $y from 1 through $y {
+        $tmp: append($tmp, 0)
+      }
+      $matrix: append($matrix, $tmp);
+    }
+    @return $matrix;
+  }
+  @return false;
+}

data/stylesheets/functions/init/_unit-matrix.scss

@@ -0,0 +1,25 @@
+// Initializing a matrix of `$x` by `$y` with its diagonal filled with 1s
+// --------------------------------------------------------------------------------
+// @require `_valid-coords`
+// @require `matrix`
+// @require `set-entry`
+// --------------------------------------------------------------------------------
+// @param $x: number of rows
+// @param $y: number of columns
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function unit-matrix($x, $y: $x) {
+  @if _valid-coords(($x $y)) {
+    $matrix: matrix($x, $y);
+    @for $i from 1 through $x {
+      @for $j from 1 through $y {
+        @if $i == $j {
+          $matrix: set-entry($matrix, ($i $j), 1);
+        }
+      }
+    }
+    @return $matrix;
+  }
+  @return false;
+}

data/stylesheets/functions/misc/_add-matrices.scss

@@ -0,0 +1,33 @@
+// Add `$matrices`
+// --------------------------------------------------------------------------------
+// @require `rows`
+// @require `columns`
+// @require `get-entry`
+// @require `set-entry`
+// --------------------------------------------------------------------------------
+// @param $matrices: matrices
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function add-matrices($matrices...) {
+  $matrix: nth($matrices, 1);
+  @each $m in $matrices {
+    @if columns($matrix) != columns($m)
+    or rows($matrix) != rows($m) {
+      @warn "All matrices do not have same dimensions.";
+      @return false;
+    }
+  }
+
+  @for $i from 1 through rows($matrix) {
+    @for $j from 1 through columns($matrix) {
+      $value: null;
+      @each $m in $matrices {
+        $entry: get-entry($m, ($i $j));
+        $value: if($value == null, $entry, $value + $entry);
+      }
+      $matrix: set-entry($matrix, ($i $j), $value);
+    }
+  }
+  @return $matrix;
+}

data/stylesheets/functions/misc/_columns.scss

@@ -0,0 +1,9 @@
+// Returns number of columns in `$matrix`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// --------------------------------------------------------------------------------
+// @return number
+
+@function columns($matrix) {
+  @return length(nth($matrix, 1));
+}

data/stylesheets/functions/misc/_display.scss

@@ -0,0 +1,42 @@
+// Returns the visual representation of `$matrix` as a string
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix to display
+// --------------------------------------------------------------------------------
+// @return string
+
+@function display($matrix) {
+  $str: "";
+  @each $line in $matrix {
+    $tmp: "";
+    @each $item in $line {
+      $tmp: $tmp + " " + $item;
+    }
+    $str: $str + $tmp + "\A ";
+  }
+  @return $str;
+}
+
+// Mixin displaying the matrix
+// using body pseudo-elements
+//
+// @param $matrix: matrix to display
+// @param $pseudo: pseudo element to use
+
+@mixin display($matrix, $pseudo: before) {
+    body:#{$pseudo} {
+        content: display($matrix)                 !important;
+
+        display: block                            !important;
+        margin: 1em                               !important;
+        padding: .5em                             !important;
+
+        background: #EFEFEF                       !important;
+        border: 1px solid #DDD                    !important;
+        border-radius: .2em                       !important;
+
+        color: #333                               !important;
+        font: 1.5em/1.5 "Courier New", monospace  !important;
+        text-shadow: 0 1px white                  !important;
+        white-space: pre-wrap                     !important;
+    }
+}

data/stylesheets/functions/misc/_rows.scss

@@ -0,0 +1,9 @@
+// Returns number of rows in `$matrix`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// --------------------------------------------------------------------------------
+// @return number
+
+@function rows($matrix) {
+  @return length($matrix);
+}

data/stylesheets/functions/misc/_transpose.scss

@@ -0,0 +1,22 @@
+// Translate `$matrix` on its diagonal axe
+// --------------------------------------------------------------------------------
+// @require `matrix`
+// @require `columns`
+// @require `rows`
+// @require `get-entry`
+// @require `set-entry`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function transpose($matrix) {
+  $new-matrix: matrix(columns($matrix), rows($matrix));
+  @for $i from 1 through rows($matrix) {
+    @for $j from 1 through columns($matrix) {
+      $entry: get-entry($matrix, ($i $j));
+      $new-matrix: set-entry($new-matrix, ($j $i), $entry);
+    }
+  }
+  @return $new-matrix;
+}

data/stylesheets/functions/setters/_add-column.scss

@@ -0,0 +1,35 @@
+// Add a new `$column` to `$matrix` at `$index`
+// --------------------------------------------------------------------------------
+// @require `rows`
+// @require `swap-columns`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $column: column to add
+// @param $index: index to add column at
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function add-column($matrix, $column: (), $index: null) {
+  $desired-length: rows($matrix);
+
+  @if $column == () {
+    @for $i from 1 through $desired-length {
+      $column: append($column, 0);
+    }
+  }
+  
+  @if length($column) != $desired-length {
+    @warn "Wrong length for new column; should be #{$desired-length}.";
+    @return false;
+  }
+  
+  @for $i from 1 through $desired-length {
+    $matrix: set-nth($matrix, $i, append(nth($matrix, $i), nth($column, $i)));
+  }
+
+  @if $index != null {
+    $matrix: swap-columns($matrix, -1, $index);
+  }
+  
+  @return $matrix;
+}

data/stylesheets/functions/setters/_add-row.scss

@@ -0,0 +1,33 @@
+// Add a new `$row` to `$matrix`
+// --------------------------------------------------------------------------------
+// @require `swap-rows`
+// @require `columns`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $row: row to add
+// @param $index: index to add row at
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function add-row($matrix, $row: (), $index: null) {
+  $desired-length: columns($matrix);
+
+  @if $row == () {
+    @for $i from 1 through $desired-length {
+      $row: append($row, 0);
+    }
+  }
+  
+  @if length($row) != $desired-length {
+    @warn "Wrong length for new row; should be #{$desired-length}.";
+    @return false;
+  }
+  
+  $matrix: append($matrix, $row);
+
+  @if $index != null {
+    $matrix: swap-rows($matrix, -1, $index);
+  }
+
+  @return $matrix;
+}

data/stylesheets/functions/setters/_set-column.scss

@@ -0,0 +1,42 @@
+// Set `$column` at `$index` in `$matrix`
+// --------------------------------------------------------------------------------
+// @require `set-entry`
+// @require `rows`
+// @require `columns`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $column: column
+// @param $index: index
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function set-column($matrix, $index, $column: ()) {
+  $desired-length: rows($matrix);
+
+  @if type-of($index) != number {
+    @warn "Invalid column index.";
+    @return false;
+  }
+
+  @if abs($index) > columns($matrix) {
+    @warn "Out of bound column index.";
+    @return false;
+  }
+
+  @if $column == () {
+    @for $i from 1 through $desired-length {
+      $column: append($column, 0);
+    }
+  }
+
+  @if length($column) != $desired-length {
+    @warn "Wrong length for new column; should be #{$desired-length}.";
+    @return false;
+  }
+
+  @for $i from 1 through $desired-length {
+    $matrix: set-entry($matrix, $i $index, nth($column, $i));
+  }
+
+  @return $matrix;
+}

data/stylesheets/functions/setters/_set-entry.scss

@@ -0,0 +1,19 @@
+// Assign `$value` at `$matrix[$coords[1], $coords[2]]`
+// --------------------------------------------------------------------------------
+// @require `_valid-coords`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix to update
+// @param $coords: (x y) coordinates
+// @param $value: value to assign at $matrix[$x, $y]
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function set-entry($matrix, $coords, $value) {
+  @if length($coords) == 1 {
+    $coords: ($coords $coords);
+  }
+  @if _valid-coords($coords, $matrix) {
+    @return set-nth($matrix, nth($coords, 1), set-nth(nth($matrix, nth($coords, 1)), nth($coords, 2), $value));
+  }
+  @return false;
+}

data/stylesheets/functions/setters/_set-row.scss

@@ -0,0 +1,37 @@
+// Set `$row` at `$index` in `$matrix`
+// --------------------------------------------------------------------------------
+// @require `columns`
+// @require `rows`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $row: row
+// @param $index: index
+// --------------------------------------------------------------------------------
+// @return matrix
+
+@function set-row($matrix, $index, $row: ()) {
+  $desired-length: columns($matrix);
+
+  @if type-of($index) != number {
+    @warn "Invalid row index.";
+    @return false;
+  }
+
+  @if abs($index) > rows($matrix) {
+    @warn "Out of bound row index.";
+    @return false;
+  }
+
+  @if $row == () {
+    @for $i from 1 through $desired-length {
+      $row: append($row, 0);
+    }
+  }
+
+  @if length($row) != $desired-length {
+    @warn "Wrong length for new row; should be #{$desired-length}.";
+    @return false;
+  }
+
+  @return set-nth($matrix, $index, $row);
+}

data/stylesheets/functions/swap/_swap-columns.scss

@@ -0,0 +1,32 @@
+// Swaps columns `$c1` and `$c2` from `$matrix`
+// --------------------------------------------------------------------------------
+// @require `rows`
+// @require `columns`
+// @require `get-entry`
+// @require `set-entry`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $c1: index of column 1
+// @param $c2: index of column 2
+// --------------------------------------------------------------------------------
+// @return $matrix
+
+@function swap-columns($matrix, $c1, $c2) {
+  @if type-of($c1) != number or type-of($c2) != number {
+    @warn "Invalid column index.";
+    @return false;
+  }
+  
+  @if abs($c1) > columns($matrix) or abs($c2) > columns($matrix) {
+    @warn "Out of bounds column index.";
+    @return false;
+  }
+
+  @for $i from 1 through rows($matrix) {
+    $tmp: get-entry($matrix, ($i $c1));
+    $matrix: set-entry($matrix, ($i $c1), get-entry($matrix, ($i $c2)));
+    $matrix: set-entry($matrix, ($i $c2), $tmp);
+  }
+
+  @return $matrix;
+}

data/stylesheets/functions/swap/_swap-entries.scss

@@ -0,0 +1,20 @@
+// Swaps entries `$e1` and `$e2` from `$matrix`
+// --------------------------------------------------------------------------------
+// @require `_valid-coords`
+// @require `get-entry`
+// @require `set-entry`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $e1: (x y) coordinates of first entry
+// @param $e2: (x y) coordinates of second entry
+// --------------------------------------------------------------------------------
+// @return $matrix
+
+@function swap-entries($matrix, $e1, $e2) {
+  @if _valid-coords($e1, $matrix) and _valid-coords($e2, $matrix) {
+    $tmp: get-entry($matrix, $e1);
+    $matrix: set-entry(set-entry($matrix, $e1, get-entry($matrix, $e2)), $e2, $tmp);
+    @return $matrix;
+  }
+  @return false;
+}

data/stylesheets/functions/swap/_swap-rows.scss

@@ -0,0 +1,24 @@
+// Swaps rows `$r1` and `$r2` from `$matrix`
+// --------------------------------------------------------------------------------
+// @require `rows`
+// --------------------------------------------------------------------------------
+// @param $matrix: matrix
+// @param $r1: index of row 1
+// @param $r2: index of row 2
+// --------------------------------------------------------------------------------
+// @return $matrix
+
+@function swap-rows($matrix, $r1, $r2) {
+  @if type-of($r1) != number or type-of($r2) != number {
+    @warn "Invalid row index.";
+    @return false;
+  }
+
+  @if abs($r1) > rows($matrix) or abs($r2) > rows($matrix) {
+    @warn "Out of bounds row index.";
+    @return false;
+  }
+
+  $tmp: nth($matrix, $r1);
+  @return set-nth(set-nth($matrix, $r1, nth($matrix, $r2)), $r2, $tmp);
+}

data/stylesheets/matrix.scss

@@ -0,0 +1,103 @@
+// Displaying matrix
+// @dep: none
+@import "functions/misc/display";
+
+// Getting number of rows in matrix
+// @dep: none
+@import "functions/misc/rows";
+
+// Getting number of columns in matrix
+// @dep: none
+@import "functions/misc/columns";
+
+// Validate coordinates pairs
+// @dep: none
+@import "functions/helpers/valid-coords";
+
+// Creating a matrix
+// @dep: `_valid-coords`
+@import "functions/init/matrix";
+
+// Assigning values to matrix
+// @dep: `_valid-coords`
+@import "functions/setters/set-entry";
+
+// Reading values from matrix
+// @dep: `_valid-coords`
+@import "functions/getters/get-entry";
+
+// Reading values from matrix
+// @dep: `rows`
+@import "functions/getters/get-row";
+
+// Swapper two rows from matrix
+// @dep: `rows`
+@import "functions/swap/swap-rows";
+
+// Assigning values to matrix
+// @dep: `rows`, `columns`
+@import "functions/setters/set-row";
+
+// Checking if matrix is square
+// @dep: `rows`, `columns`
+@import "functions/checkers/is-square";
+
+// Transpose a matrix
+// @dep: `columns`, `swap-rows`
+@import "functions/setters/add-row";
+
+// Transpose a matrix
+// @dep: `rows`, `swap-columns`
+@import "functions/setters/add-column";
+
+// Assigning values to matrix
+// @dep: `rows`, `columns`, `set-entry`
+@import "functions/setters/set-column";
+
+// Reading values from matrix
+// @dep: `rows`, `columns`, `get-entry`
+@import "functions/getters/get-column";
+
+// Checking if all values from matrix are numbers
+// @dep: `rows`, `columns`, `get-entry`
+@import "functions/checkers/is-numeric";
+
+// Checking if matrix is diagonal
+// @dep: `rows`, `columns`, `get-entry`
+@import "functions/checkers/is-diagonal";
+
+// Is triangular helper
+// @dep: `rows`, `columns`, `get-entry`
+@import "functions/helpers/is-triangular";
+
+// Creating a matrix with diagonal filled
+// @dep: `matrix`, `_valid-coords`, `set-entry`
+@import "functions/init/unit-matrix";
+
+// Swapping two values from matrix
+// @dep: `_valid-coords`, `get-entry`, `set-entry`
+@import "functions/swap/swap-entries";
+
+// Swapper two columns from matrix
+// @dep: `rows`, `columns`, `get-entry`, `set-entry`
+@import "functions/swap/swap-columns";
+
+// Checking if matrix is diagonal
+// @dep: `rows`, `columns`, `get-entry`, `_is-triangular`
+@import "functions/checkers/is-upper-triangular";
+
+// Checking if matrix is diagonal
+// @dep: `rows`, `columns`, `get-entry`, `_is-triangular`
+@import "functions/checkers/is-lower-triangular";
+
+// Add two matrices
+// @dep: `rows`, `columns`, `get-entry`, `set-entry`
+@import "functions/misc/add-matrices";
+
+// Transpose a matrix
+// @dep: `rows`, `columns`, `get-entry`, `set-entry`
+@import "functions/misc/transpose";
+
+// Displaying matrix
+// @dep: `is-square`, `transpose`
+@import "functions/checkers/is-symmetric";

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: SassyMatrix
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Hugo Giraudel
+- Fabrice Weinberg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-23 00:00:00.000000000 Z
+dependencies: []
+description: Sass API for matrices
+email:
+- hugo.giraudel@gmail.com
+- fabrice@weinberg.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- CHANGELOG.md
+- lib/SassyMatrix.rb
+- stylesheets/functions/checkers/_is-diagonal.scss
+- stylesheets/functions/checkers/_is-lower-triangular.scss
+- stylesheets/functions/checkers/_is-numeric.scss
+- stylesheets/functions/checkers/_is-square.scss
+- stylesheets/functions/checkers/_is-symmetric.scss
+- stylesheets/functions/checkers/_is-upper-triangular.scss
+- stylesheets/functions/getters/_get-column.scss
+- stylesheets/functions/getters/_get-entry.scss
+- stylesheets/functions/getters/_get-row.scss
+- stylesheets/functions/helpers/_is-triangular.scss
+- stylesheets/functions/helpers/_valid-coords.scss
+- stylesheets/functions/init/_matrix.scss
+- stylesheets/functions/init/_unit-matrix.scss
+- stylesheets/functions/misc/_add-matrices.scss
+- stylesheets/functions/misc/_columns.scss
+- stylesheets/functions/misc/_display.scss
+- stylesheets/functions/misc/_rows.scss
+- stylesheets/functions/misc/_transpose.scss
+- stylesheets/functions/setters/_add-column.scss
+- stylesheets/functions/setters/_add-row.scss
+- stylesheets/functions/setters/_set-column.scss
+- stylesheets/functions/setters/_set-entry.scss
+- stylesheets/functions/setters/_set-row.scss
+- stylesheets/functions/swap/_swap-columns.scss
+- stylesheets/functions/swap/_swap-entries.scss
+- stylesheets/functions/swap/_swap-rows.scss
+- stylesheets/matrix.scss
+homepage: https://github.com/HugoGiraudel/SassyMatrix/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: SassyMatrix
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: SassyMatrix is a Sass-powered API for matrices.
+test_files: []