//===----------------------------------------------------------*- swift -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
// simd.h overlays for Swift
//===----------------------------------------------------------------------===//

import Darwin
import simd

% component = ['x','y','z','w']
% scalar_types = ['Float','Double','Int32']
% ctype = { 'Float':'float', 'Double':'double', 'Int32':'int' }
% floating_types = ['Float','Double']
% cardinal = { 2:'two', 3:'three', 4:'four'}
% hash_scales = ['1', '3', '5', '11']
% one_minus_ulp = { 'Float':'0x1.fffffep-1', 'Double':'0x1.fffffffffffffp-1' }

% for type in scalar_types:
%   for size in [2, 3, 4]:
//    Workaround <rdar://problem/18900352>
%     vectype = ctype[type] + str(size)
%     vecsize = (8 if type == 'Double' else 4)*(2 if size == 2 else 4)

/// A vector of ${cardinal[size]} `${type}`.  This corresponds to the C and
/// Obj-C type `vector_${vectype}` and the C++ type `simd::${vectype}`.
@_alignment(${vecsize})
public struct ${vectype} :
  ArrayLiteralConvertible, CustomDebugStringConvertible {
  public var ${', '.join(component[:size])}: ${type}
% if size == 3:
  /// Three-element vectors require padding so that their size is the same as
  /// the size of the corresponding C, Obj-C, and C++ types.
  internal let _padding: ${type} = 0
% end

  /// Initialize to the zero vector.
  public init() { self.init(0) }

  /// Initialize a vector with the specified elements.
  public init(${', '.join(map(lambda c: c + ': ' + type, component[:size]))}) {
% for c in component[:size]:
    self.${c} = ${c}
% end
  }

  /// Initialize to a vector with all elements equal to `scalar`.
  public init(_ scalar: ${type}) {
    self.init(${', '.join(map(lambda c: c + ': scalar', component[:size]))})
  }

  /// Initialize to a vector with elements taken from `array`.
  ///
  /// - Precondition: `array` must have exactly ${cardinal[size]} elements.
  public init(_ array: [${type}]) {
  _precondition(array.count == ${size},
                "${vectype} requires a ${cardinal[size]}-element array")
    self.init(${', '.join(map(lambda i:
              component[i] + ': array[' + str(i) + ']',
              range(size)))})
  }

  /// Initialize using `arrayLiteral`.
  ///
  /// - precondition: the array literal must exactly ${cardinal[size]} elements.
  public init(arrayLiteral elements: ${type}...) { self.init(elements) }

  /// Access individual elements of the vector via subscript.
  public subscript(index: Int) -> ${type} {
    get {
      switch index {
%     for i in range(size):
      case ${i}: return ${component[i]}
%     end
      default: _preconditionFailure("Vector index out of range")
      }
    }
    set(value) {
      switch index {
%     for i in range(size):
      case ${i}: ${component[i]} = value
%     end
      default: _preconditionFailure("Vector index out of range")
      }
    }
  }

  /// Debug string representation
  public var debugDescription: String {
    return "${vectype}(\(self._descriptionAsArray))"
  }

  /// Helper function for vector and matrix debug representations
  internal var _descriptionAsArray: String {
    get {
      return "[${', '.join(map(lambda c:
               '\\(' + c + ')',
               component[:size]))}]"
    }
  }
}

/// Vector sum of `lhs` and `rhs`.
@inline(__always)
public func +(lhs: ${vectype}, rhs: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c: \
                    c + ':lhs.' + c + '+rhs.' + c,
                    component[:size]))})
}

/// Vector difference of `lhs` and `rhs`.
@inline(__always)
public func -(lhs: ${vectype}, rhs: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c: \
                    c + ':lhs.' + c + '-rhs.' + c,
                    component[:size]))})
}

/// Negation of `rhs`.
@inline(__always)
public prefix func -(rhs: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c: \
                    c + ':-rhs.' + c,
                    component[:size]))})
}

/// Elementwise product of `lhs` and `rhs`.  A.k.a. the Hadamard or Schur
/// product of the two vectors.
@inline(__always)
public func *(lhs: ${vectype}, rhs: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c: \
                    c + ':lhs.' + c + '*rhs.' + c,
                    component[:size]))})
}

/// Elementwise quotient of `lhs` and `rhs`.  This is the inverse operation
/// of the elementwise product.
@inline(__always)
public func /(lhs: ${vectype}, rhs: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c: \
                    c + ':lhs.' + c + '/rhs.' + c,
                    component[:size]))})
}

/// Add `rhs` to `lhs`.
@inline(__always)
public func +=(inout lhs: ${vectype}, rhs: ${vectype}) -> Void {
  lhs = lhs + rhs
}

/// Subtract `rhs` from `lhs`.
@inline(__always)
public func -=(inout lhs: ${vectype}, rhs: ${vectype}) -> Void {
  lhs = lhs - rhs
}

/// Multiply `lhs` by `rhs` (elementwise).
@inline(__always)
public func *=(inout lhs: ${vectype}, rhs: ${vectype}) -> Void {
  lhs = lhs * rhs
}

/// Divide `lhs` by `rhs` (elementwise).
@inline(__always)
public func /=(inout lhs: ${vectype}, rhs: ${vectype}) -> Void {
  lhs = lhs / rhs
}

/// Scalar-Vector product.
@inline(__always)
public func *(lhs: ${type}, rhs: ${vectype}) -> ${vectype} {
  return ${vectype}(lhs) * rhs
}

/// Scalar-Vector product.
@inline(__always)
public func *(lhs: ${vectype}, rhs: ${type}) -> ${vectype} {
  return lhs * ${vectype}(rhs)
}

/// Scales `lhs` by `rhs`.
@inline(__always)
public func *=(inout lhs: ${vectype}, rhs: ${type}) -> Void {
  lhs = lhs * rhs
}

/// Elementwise absolute value of a vector.  The result is a vector of the same
/// length with all elements positive.
@inline(__always)
public func abs(x: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c: \
                    c + ': abs(x.' + c + ')', \
                    component[:size]))})
}

/// Elementwise minimum of two vectors.  Each component of the result is the
/// smaller of the corresponding component of the inputs.
@inline(__always)
public func min(x: ${vectype}, _ y: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:             \
                    c + ': min(x.' + c + ',y.' + c + ')', \
                    component[:size]))})
}

/// Elementwise maximum of two vectors.  Each component of the result is the
/// larger of the corresponding component of the inputs.
@inline(__always)
public func max(x: ${vectype}, _ y: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:             \
                    c + ': max(x.' + c + ',y.' + c + ')', \
                    component[:size]))})
}

/// Vector-scalar minimum.  Each component of the result is the minimum of the
/// corresponding element of the input vector and the scalar.
@inline(__always)
public func min(vector: ${vectype}, _ scalar: ${type}) -> ${vectype} {
  return min(vector, ${vectype}(scalar))
}

/// Vector-scalar maximum.  Each component of the result is the maximum of the
/// corresponding element of the input vector and the scalar.
@inline(__always)
public func max(vector: ${vectype}, _ scalar: ${type}) -> ${vectype} {
  return max(vector, ${vectype}(scalar))
}

/// Each component of the result is the corresponding element of `x` clamped to
/// the range formed by the corresponding elements of `min` and `max`.  Any
/// lanes of `x` that contain NaN will end up with the `min` value.
@inline(__always)
public func clamp(x: ${vectype},
                  min: ${vectype},
                  max: ${vectype})
                    -> ${vectype} {
  return simd.min(simd.max(x, min), max)
}

/// Clamp each element of `x` to the range [`min`, max].  If any lane of `x` is
/// NaN, the corresponding lane of the result is `min`.
@inline(__always)
public func clamp(x: ${vectype},
                  min: ${type},
                  max: ${type})
                    -> ${vectype} {
  return simd.min(simd.max(x, min), max)
}

/// Sum of the elements of the vector.
@inline(__always)
public func reduce_add(x: ${vectype}) -> ${type} {
  return ${' + '.join(map(lambda x:'x.'+x, component[:size]))}
}

/// Minimum element of the vector.
@inline(__always)
public func reduce_min(x: ${vectype}) -> ${type} {
  return min(${', '.join(map(lambda x:'x.'+x, component[:size]))})
}

/// Maximum element of the vector.
@inline(__always)
public func reduce_max(x: ${vectype}) -> ${type} {
  return max(${', '.join(map(lambda x:'x.'+x, component[:size]))})
}

%     if type in floating_types:

/// Sign of a vector.  Each lane contains -1 if the corresponding lane of `x`
/// is less than zero, +1 if the corresponding lane of `x` is greater than
/// zero, and 0 otherwise.
@inline(__always)
public func sign(x: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:  \
                    c + ': sign(x.' + c + ')', \
                    component[:size]))})
}

/// Linear interpolation between `x` (at `t=0`) and `y` (at `t=1`).  May be
/// used with `t` outside of [0, 1] as well.
@inline(__always)
public func mix(x: ${vectype}, _ y: ${vectype}, t: ${vectype}) -> ${vectype} {
  return x + t*(y-x)
}

/// Linear interpolation between `x` (at `t=0`) and `y` (at `t=1`).  May be
/// used with `t` outside of [0, 1] as well.
@inline(__always)
public func mix(x: ${vectype}, _ y: ${vectype}, t: ${type}) -> ${vectype} {
  return x + t*(y-x)
}

/// Elementwise reciprocal.
@inline(__always)
public func recip(x: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:  \
                    c + ': recip(x.' + c + ')', \
                    component[:size]))})
}

/// Elementwise reciprocal square root.
@inline(__always)
public func rsqrt(x: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:  \
                    c + ': rsqrt(x.' + c + ')', \
                    component[:size]))})
}

/// Alternate name for minimum of two floating-point vectors.
@inline(__always)
public func fmin(x: ${vectype}, _ y: ${vectype}) -> ${vectype} {
  return min(x, y)
}

/// Alternate name for maximum of two floating-point vectors.
@inline(__always)
public func fmax(x: ${vectype}, _ y: ${vectype}) -> ${vectype} {
  return max(x, y)
}

/// Each element of the result is the smallest integral value greater than or
/// equal to the corresponding element of the input.
@inline(__always)
public func ceil(x: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:  \
                    c + ': ceil(x.' + c + ')', \
                    component[:size]))})
}

/// Each element of the result is the largest integral value less than or equal
/// to the corresponding element of the input.
@inline(__always)
public func floor(x: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:  \
                    c + ': floor(x.' + c + ')', \
                    component[:size]))})
}

/// Each element of the result is the closest integral value with magnitude
/// less than or equal to that of the corresponding element of the input.
@inline(__always)
public func trunc(x: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:  \
                    c + ': trunc(x.' + c + ')', \
                    component[:size]))})
}

/// `x - floor(x)`, clamped to lie in the range [0,1).  Without this clamp step,
/// the result would be 1.0 when `x` is a very small negative number, which may
/// result in out-of-bounds table accesses in common usage.
@inline(__always)
public func fract(x: ${vectype}) -> ${vectype} {
  return fmin(x - floor(x), ${vectype}(${one_minus_ulp[type]}))
}

/// 0.0 if `x < edge`, and 1.0 otherwise.
@inline(__always)
public func step(x: ${vectype}, edge: ${vectype}) -> ${vectype} {
  return ${vectype}(${', '.join(map(lambda c:                 \
                    c + ': step(x.' + c + ', edge: edge.' + c + ')', \
                    component[:size]))})
}

/// 0.0 if `x < edge0`, 1.0 if `x > edge1`, and cubic interpolation between
/// 0 and 1 in the interval [edge0, edge1].
@inline(__always)
public func smoothstep(x: ${vectype},
                              edge0: ${vectype},
                              edge1: ${vectype})
                                -> ${vectype} {
  let t = clamp((x-edge0)/(edge1-edge0), min: 0, max: 1)
  return t*t*(${vectype}(3) - 2*t)
}

/// Dot product of `x` and `y`.
@inline(__always)
public func dot(x: ${vectype}, _ y: ${vectype}) -> ${type} {
  return reduce_add(x*y)
}

/// Projection of `x` onto `y`.
@inline(__always)
public func project(x: ${vectype}, _ y: ${vectype}) -> ${vectype} {
  return dot(x,y)/dot(y,y)*y
}

/// Length of `x`, squared.  This is more efficient to compute than the length,
/// so you should use it if you only need to compare lengths to each other.
/// I.e. instead of writing:
///
///   if (length(x) < length(y)) { ... }
///
/// use:
///
///   if (length_squared(x) < length_squared(y)) { ... }
///
/// Doing it this way avoids one or two square roots, which is a fairly costly
/// operation.
@inline(__always)
public func length_squared(x: ${vectype}) -> ${type} {
  return dot(x,x)
}

/// Length (two-norm or "Euclidean norm") of `x`.
@inline(__always)
public func length(x: ${vectype}) -> ${type} {
  return sqrt(length_squared(x))
}

/// The one-norm (or "taxicab norm") of `x`.
@inline(__always)
public func norm_one(x: ${vectype}) -> ${type} {
  return reduce_add(abs(x))
}

/// The infinity-norm (or "sup norm") of `x`.
@inline(__always)
public func norm_inf(x: ${vectype}) -> ${type} {
  return reduce_max(abs(x))
}

/// Distance between `x` and `y`, squared.
@inline(__always)
public func distance_squared(x: ${vectype}, y: ${vectype}) -> ${type} {
  return length_squared(x - y)
}

/// Distance between `x` and `y`.
@inline(__always)
public func distance(x: ${vectype}, y: ${vectype}) -> ${type} {
  return length(x - y)
}

/// Unit vector pointing in the same direction as `x`.  normalize(0) is 0.
@inline(__always)
public func normalize(x: ${vectype}) -> ${vectype} {
  return x * rsqrt(length_squared(x))
}

/// `x` reflected through the hyperplane with unit normal vector `n`, passing
/// through the origin.  E.g. if `x` is [1,2,3] and `n` is [0,0,1], the result
/// is [1,2,-3].
@inline(__always)
public func reflect(x: ${vectype}, n: ${vectype}) -> ${vectype} {
  return x - 2*dot(x,n)*n
}

/// The refraction direction given unit incident vector `x`, unit surface
/// normal `n`, and index of refraction `eta`.  If the angle between the
/// incident vector and the surface is so small that total internal reflection
/// occurs, zero is returned.
@inline(__always)
public func refract(x: ${vectype},
                           n: ${vectype},
                           eta: ${type})
                             -> ${vectype} {
  let k = 1 - eta*eta*(1 - dot(x,n)*dot(x,n))
  if k >= 0 { return eta*x - (eta*dot(x,n) + sqrt(k))*n }
  return ${vectype}(0)
}

%     end # if type in floating_types
%   end # for size in [2, 3, 4]
%   if type in floating_types:
//  Scalar versions of common operations:

/// Returns -1 if `x < 0`, +1 if `x > 0`, and 0 otherwise (`sign(NaN)` is 0).
@inline(__always)
public func sign(x: ${type}) -> ${type} {
  return x < 0 ? -1 : (x > 0 ? 1 : 0)
}

/// Reciprocal.
@inline(__always)
public func recip(x: ${type}) -> ${type} { return 1/x }

/// Reciprocal square root.
@inline(__always)
public func rsqrt(x: ${type}) -> ${type} { return 1/sqrt(x) }

/// Returns 0.0 if `x < edge`, and 1.0 otherwise.
@inline(__always)
public func step(x: ${type}, edge: ${type}) -> ${type} {
  return x < edge ? 0.0 : 1.0
}

/// Interprets two two-dimensional vectors as three-dimensional vectors in the
/// xy-plane and computes their cross product, which lies along the z-axis.
@inline(__always)
public func cross(x: ${ctype[type]}2,
                       _ y: ${ctype[type]}2)
                         -> ${ctype[type]}3 {
  return ${ctype[type]}3(x: 0, y: 0, z: x.x*y.y - x.y*y.x)
}

/// Cross-product of two three-dimensional vectors.  The resulting vector is
/// perpendicular to the plane determined by `x` and `y`, with length equal to
/// the oriented area of the parallelogram they determine.
@inline(__always)
public func cross(x: ${ctype[type]}3,
                       _ y: ${ctype[type]}3)
                         -> ${ctype[type]}3 {
  return ${ctype[type]}3(x: x.y*y.z - x.z*y.y,
                     y: x.z*y.x - x.x*y.z,
                     z: x.x*y.y - x.y*y.x)
}
%   end # type in floating_types
% end # for type in scalar_types

% for type in floating_types:
%   for rows in [2,3,4]:
//      Workaround <rdar://problem/18900352>
%     for cols in [2,3,4]:
//      Workaround <rdar://problem/18900352>
%       mattype = ctype[type] + str(cols) + 'x' + str(rows)
%       diagsize = rows if rows < cols else cols
%       coltype = ctype[type] + str(rows)
%       rowtype = ctype[type] + str(cols)
%       diagtype = ctype[type] + str(diagsize)
%       transtype = ctype[type] + str(rows) + 'x' + str(cols)
%       cmatrix = 'matrix_' + mattype

public struct ${mattype} : CustomDebugStringConvertible {

  internal var _columns: (${', '.join([coltype]*cols)})

  /// Initialize matrix to zero.
  public init() {
%   for i in range(cols):
    _columns.${i} = ${coltype}()
%   end
  }

  /// Initialize matrix to have `scalar` on main diagonal, zeros elsewhere.
  public init(_ scalar: ${type}) {
    self.init(diagonal: ${diagtype}(scalar))
  }

  /// Initialize matrix to have specified `diagonal`, and zeros elsewhere.
  public init(diagonal: ${diagtype}) {
%   for i in range(cols):
    self._columns.${i} = ${coltype}()
%   end
%   for i in range(diagsize):
    self._columns.${i}.${component[i]} = diagonal.${component[i]}
%   end
  }

  /// Initialize matrix to have specified `columns`.
  public init(_ columns: [${coltype}]) {
    _precondition(columns.count == ${cols}, "Requires array of ${cols} vectors")
%   for i in range(cols):
    self._columns.${i} = columns[${i}]
%   end
  }

  /// Initialize matrix to have specified `rows`.
  public init(rows: [${rowtype}]) {
    _precondition(rows.count == ${rows}, "Requires array of ${rows} vectors")
%   for i in range(cols):
      self._columns.${i} = [${', '.join(map(lambda j:
                            'rows[' + str(j) + '].' + component[i],
                            range(rows)))}]
%   end
  }

  /// Initialize matrix to have specified `columns`.
  internal init(${', '.join(map(lambda i:
                '_ col' + str(i) + ': ' + coltype,
                range(cols)))}) {
%   for i in range(cols):
      self._columns.${i} = col${i}
%   end
  }

  /// Initialize matrix from corresponding C matrix type.
  public init(_ cmatrix: ${cmatrix}) {
    self = unsafeBitCast(cmatrix, ${mattype}.self)
  }

  /// Get the matrix as the corresponding C matrix type.
  public var cmatrix: ${cmatrix} {
    get { return unsafeBitCast(self, ${cmatrix}.self) }
  }

  /// Access to individual columns.
  public subscript(column: Int) -> ${coltype} {
    get {
      switch(column) {
% for i in range(cols):
      case ${i}: return _columns.${i}
% end
      default: _preconditionFailure("Column index out of range")
      }
    }
    set (value) {
      switch(column) {
% for i in range(cols):
      case ${i}: _columns.${i} = value
% end
      default: _preconditionFailure("Column index out of range")
      }
    }
  }

  /// Access to individual elements.
  public subscript(column: Int, row: Int) -> ${type} {
    get { return self[column][row] }
    set (value) { self[column][row] = value }
  }

  public var debugDescription: String {
    return "${mattype}([${', '.join(map(lambda i: \
                        '\(_columns.' + str(i) + '._descriptionAsArray)',
                        range(cols)))}])"
  }

  /// Transpose of the matrix.
  public var transpose: ${transtype} {
    get {
      return ${transtype}([
% for i in range(rows):
        [${', '.join(map(lambda j: \
         'self[' + str(j) + ',' + str(i) + ']', \
         range(cols)))}],
% end # for i in range(rows)
      ])
    }
  }

% if rows == cols:
  /// Inverse of the matrix if it exists, otherwise the contents of the
  /// resulting matrix are undefined.
  public var inverse: ${mattype} {
    get {
      % inverse_func = '__invert_' + ('f' if type == 'Float' else 'd') + str(cols)
      return ${mattype}(${inverse_func}(self.cmatrix))
    }
  }
% end
}

/// Sum of two matrices.
public func +(lhs: ${mattype}, rhs: ${mattype}) -> ${mattype} {
  return ${mattype}(${', '.join(map(lambda i: \
                    'lhs._columns.'+str(i)+' + rhs._columns.'+str(i), \
                    range(cols)))})
}

/// Negation of a matrix.
public prefix func -(rhs: ${mattype}) -> ${mattype} {
  return ${mattype}(${', '.join(map(lambda i: \
                    '-rhs._columns.'+str(i),  \
                    range(cols)))})
}

/// Difference of two matrices.
public func -(lhs: ${mattype}, rhs: ${mattype}) -> ${mattype} {
  return ${mattype}(${', '.join(map(lambda i: \
                    'lhs._columns.'+str(i)+' - rhs._columns.'+str(i), \
                    range(cols)))})
}

public func +=(inout lhs: ${mattype}, rhs: ${mattype}) -> Void {
  lhs = lhs + rhs
}

public func -=(inout lhs: ${mattype}, rhs: ${mattype}) -> Void {
  lhs = lhs - rhs;
}

/// Scalar-Matrix multiplication.
public func *(lhs: ${type}, rhs: ${mattype}) -> ${mattype} {
  return ${mattype}(${', '.join(map(lambda i: \
                    'lhs*rhs._columns.'+str(i), \
                    range(cols)))})
}

/// Matrix-Scalar multiplication.
public func *(lhs: ${mattype}, rhs: ${type}) -> ${mattype} {
  return rhs*lhs
}

public func *=(inout lhs: ${mattype}, rhs: ${type}) -> Void {
  lhs = lhs*rhs
}

/// Matrix-Vector multiplication.  Keep in mind that matrix types are named
/// `${type}NxM` where `N` is the number of *columns* and `M` is the number of
/// *rows*, so we multiply a `${type}3x2 * ${type}3` to get a `${type}2`, for
/// example.
public func *(lhs: ${mattype}, rhs: ${rowtype}) -> ${coltype} {
  return ${' + '.join(map(lambda i: \
         'lhs._columns.'+str(i)+'*rhs.'+component[i], \
         range(cols)))}
}

/// Vector-Matrix multiplication.
public func *(lhs: ${coltype}, rhs: ${mattype}) -> ${rowtype} {
  return ${rowtype}(${', '.join(map(lambda i: \
                    component[i]+': dot(lhs, rhs._columns.'+str(i)+')', \
                    range(cols)))})
}

% for k in [2,3,4]:
/// Matrix multiplication (the "usual" matrix product, not the elementwise
/// product).
%   lhstype = ctype[type] + str(k) + 'x' + str(rows)
%   rhstype = ctype[type] + str(cols) + 'x' + str(k)
public func *(lhs: ${lhstype}, rhs: ${rhstype}) -> ${mattype} {
  return ${mattype}(${', '.join(map(lambda i: \
                    'lhs*rhs._columns.'+str(i), \
                    range(cols)))})
}

% end # for k in [2,3,4]

%   rhstype = ctype[type] + str(cols) + 'x' + str(cols)
/// Matrix multiplication (the "usual" matrix product, not the elementwise
/// product).
public func *=(inout lhs: ${mattype}, rhs: ${rhstype}) -> Void {
  lhs = lhs*rhs
}

% end # for cols in [2,3,4]
% end # for rows in [2,3,4]
% end # for type in floating_types