KVector initial commit

build.gradle.kts

@@ -26,9 +26,21 @@ java.toolchain.languageVersion.set(JavaLanguageVersion.of(17))
 tasks.compileKotlin {
 	kotlinOptions {
 		jvmTarget = "17"
+		freeCompilerArgs += "-opt-in=kotlin.RequiresOptIn"
 	}
 }
 
+sourceSets {
+	create("kvector") {
+
+	}
+}
+
+sourceSets.test {
+	compileClasspath += sourceSets["kvector"].output
+	runtimeClasspath += sourceSets["kvector"].output
+}
+
 dependencies {
 	implementation(kotlin("stdlib"))
 	implementation(kotlin("reflect"))

gradle.properties

@@ -1 +1,2 @@
-kotlin.code.style=official
+kotlin.code.style=official
+org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=512m

src/kvector/kotlin/ru/dbotthepony/kvector/api/DoubleMatrix.kt

@@ -0,0 +1,111 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.api
+
+interface IMatrixGetterDouble : IMatrixLike {
+	/**
+	 * @return component of this matrix, as double
+	 */
+	operator fun get(column: Int, row: Int): Double
+}
+
+interface IMatrixSetterDouble : IMatrixLike {
+	/**
+	 * Sets component of this matrix, as double
+	 */
+	operator fun set(column: Int, row: Int, value: Double)
+}
+
+interface IDoubleMatrix<T : IDoubleMatrix<T>> : IMatrixGetterDouble {
+	/**
+	 * Multiplies all matrix components by [other], returning new matrix as result
+	 *
+	 * @return new matrix
+	 */
+	operator fun times(other: Double): T
+
+	/**
+	 * Divides all matrix components by [other], returning new matrix as result
+	 *
+	 * @return new matrix
+	 */
+	operator fun div(other: Double): T
+
+	/**
+	 * Multiplies this and [other] matrices by general matrix multiplication rules,
+	 * if they are compatible in dimensions, and return new matrix.
+	 *
+	 * @throws IllegalArgumentException if matrices are not applicable for multiplication
+	 * @return new matrix
+	 */
+	operator fun times(other: IMatrixGetterDouble): T
+
+	/**
+	 * Adds components of both matrices, returning new matrix as result
+	 *
+	 * @throws IllegalArgumentException if matrices are different in dimensions
+	 * @return new matrix
+	 */
+	operator fun plus(other: IMatrixGetterDouble): T
+
+	/**
+	 * Subtracts components of both matrices, returning new matrix as result
+	 *
+	 * @throws IllegalArgumentException if matrices are different in dimensions
+	 * @return new matrix
+	 */
+	operator fun minus(other: IMatrixGetterDouble): T
+
+	/**
+	 * This matrix trace. If matrix is not square matrix, null is returned.
+	 */
+	val trace: Double?
+
+	/**
+	 * This matrix determinant. If matrix is not square matrix, null is returned.
+	 */
+	val determinant: Double?
+}
+
+interface IMutableDoubleMatrix<T : IMutableDoubleMatrix<T>> : IMatrixSetterDouble {
+	/**
+	 * Multiplies all matrix components by [other], writing result into this matrix
+	 *
+	 * @return this matrix
+	 */
+	fun timesMut(other: Double): T
+
+	/**
+	 * Divides all matrix components by [other], writing result into this matrix
+	 *
+	 * @return this matrix
+	 */
+	fun divMut(other: Double): T
+
+	/**
+	 * Multiplies this and [other] matrices by general matrix multiplication rules,
+	 * if they are compatible in dimensions, and write result into this matrix.
+	 *
+	 * @throws IllegalArgumentException if [other] is not a square matrix
+	 * @throws IllegalStateException if this matrix is not a square matrix
+	 * @return this matrix
+	 */
+	fun timesMut(other: IMatrixGetterDouble): T
+
+	/**
+	 * Adds components of both matrices, writing result into this matrix
+	 *
+	 * @throws IllegalArgumentException if matrices are different in dimensions
+	 * @return this matrix
+	 */
+	fun plusMut(other: IMatrixGetterDouble): T
+
+	/**
+	 * Subtracts components of both matrices, writing result into this matrix
+	 *
+	 * @throws IllegalArgumentException if matrices are different in dimensions
+	 * @return this matrix
+	 */
+	fun minusMut(other: IMatrixGetterDouble): T
+}

src/kvector/kotlin/ru/dbotthepony/kvector/api/FloatMatrix.kt

@@ -0,0 +1,111 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.api
+
+interface IMatrixGetterFloat : IMatrixLike {
+	/**
+	 * @return component of this matrix, as float
+	 */
+	operator fun get(column: Int, row: Int): Float
+}
+
+interface IMatrixSetterFloat : IMatrixLike {
+	/**
+	 * Sets component of this matrix, as float
+	 */
+	operator fun set(column: Int, row: Int, value: Float)
+}
+
+interface IFloatMatrix<T : IFloatMatrix<T>> : IMatrixGetterFloat {
+	/**
+	 * Multiplies all matrix components by [other], returning new matrix as result
+	 *
+	 * @return new matrix
+	 */
+	operator fun times(other: Float): T
+
+	/**
+	 * Divides all matrix components by [other], returning new matrix as result
+	 *
+	 * @return new matrix
+	 */
+	operator fun div(other: Float): T
+
+	/**
+	 * Multiplies this and [other] matrices by general matrix multiplication rules,
+	 * if they are compatible in dimensions, and return new matrix.
+	 *
+	 * @throws IllegalArgumentException if matrices are not applicable for multiplication
+	 * @return new matrix
+	 */
+	operator fun times(other: IMatrixGetterFloat): T
+
+	/**
+	 * Adds components of both matrices, returning new matrix as result
+	 *
+	 * @throws IllegalArgumentException if matrices are different in dimensions
+	 * @return new matrix
+	 */
+	operator fun plus(other: IMatrixGetterFloat): T
+
+	/**
+	 * Subtracts components of both matrices, returning new matrix as result
+	 *
+	 * @throws IllegalArgumentException if matrices are different in dimensions
+	 * @return new matrix
+	 */
+	operator fun minus(other: IMatrixGetterFloat): T
+
+	/**
+	 * This matrix trace. If matrix is not square matrix, null is returned.
+	 */
+	val trace: Float?
+
+	/**
+	 * This matrix determinant. If matrix is not square matrix, null is returned.
+	 */
+	val determinant: Float?
+}
+
+interface IMutableFloatMatrix<T : IMutableFloatMatrix<T>> : IMatrixSetterFloat {
+	/**
+	 * Multiplies all matrix components by [other], writing result into this matrix
+	 *
+	 * @return this matrix
+	 */
+	fun timesMut(other: Float): T
+
+	/**
+	 * Divides all matrix components by [other], writing result into this matrix
+	 *
+	 * @return this matrix
+	 */
+	fun divMut(other: Float): T
+
+	/**
+	 * Multiplies this and [other] matrices by general matrix multiplication rules,
+	 * if they are compatible in dimensions, and write result into this matrix.
+	 *
+	 * @throws IllegalArgumentException if [other] is not a square matrix
+	 * @throws IllegalStateException if this matrix is not a square matrix
+	 * @return this matrix
+	 */
+	fun timesMut(other: IMatrixGetterFloat): T
+
+	/**
+	 * Adds components of both matrices, writing result into this matrix
+	 *
+	 * @throws IllegalArgumentException if matrices are different in dimensions
+	 * @return this matrix
+	 */
+	fun plusMut(other: IMatrixGetterFloat): T
+
+	/**
+	 * Subtracts components of both matrices, writing result into this matrix
+	 *
+	 * @throws IllegalArgumentException if matrices are different in dimensions
+	 * @return this matrix
+	 */
+	fun minusMut(other: IMatrixGetterFloat): T
+}

src/kvector/kotlin/ru/dbotthepony/kvector/api/Matrix.kt

@@ -0,0 +1,437 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.api
+
+/**
+ * Classes implementing this interface can be manipulated like matrices
+ */
+interface IMatrixLike {
+	/**
+	 * Rows this matrix has
+	 */
+	val rows: Int
+
+	/**
+	 * Columns this matrix has
+	 */
+	val columns: Int
+
+	/**
+	 * Whenever is this matrix a square matrix
+	 */
+	val isSquareMatrix: Boolean get() = rows == columns
+
+	/**
+	 * @return Whenever [other] has the same dimensions as this matrix
+	 */
+	fun sizeEquals(other: IMatrixLike): Boolean {
+		return rows == other.rows && columns == other.columns
+	}
+
+	/**
+	 * @throws IllegalArgumentException if [other] is not the same dimensions as this matrix
+	 */
+	fun requireSizeEquals(other: IMatrixLike) {
+		if (!sizeEquals(other)) {
+			throw IllegalArgumentException("Other matrix (${other.columns}x${other.rows}) is not the same dimensions as this matrix (${columns}x${rows})")
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if [other] is not the same dimensions as this matrix
+	 */
+	fun requireSizeEquals(other: IMatrixLike, lazy: () -> Any) {
+		if (!sizeEquals(other)) {
+			throw IllegalArgumentException(lazy.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if [other] is not the same dimensions as this matrix
+	 */
+	fun checkSizeEquals(other: IMatrixLike) {
+		if (!sizeEquals(other)) {
+			throw IllegalStateException("Other matrix (${other.columns}x${other.rows}) is not the same dimensions as this matrix (${columns}x${rows})")
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if [other] is not the same dimensions as this matrix
+	 */
+	fun checkSizeEquals(other: IMatrixLike, lazy: () -> Any) {
+		if (!sizeEquals(other)) {
+			throw IllegalStateException(lazy.invoke().toString())
+		}
+	}
+
+	/**
+	 * @return Whenever [other] has the same amount of rows as this matrix
+	 */
+	fun rowsEquals(other: IMatrixLike): Boolean {
+		return rows == other.rows
+	}
+
+	/**
+	 * @throws IllegalArgumentException if [other] is not the same amount of rows as this matrix
+	 */
+	fun requireRowsEquals(other: IMatrixLike) {
+		if (!rowsEquals(other)) {
+			throw IllegalArgumentException("Other matrix (${other.rows}) has different amount of rows compared to this matrix (${rows})")
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if [other] is not the same amount of rows as this matrix
+	 */
+	fun requireRowsEquals(other: IMatrixLike, lazy: () -> Any) {
+		if (!rowsEquals(other)) {
+			throw IllegalArgumentException(lazy.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if [other] is not the same amount of rows as this matrix
+	 */
+	fun checkRowsEquals(other: IMatrixLike) {
+		if (!rowsEquals(other)) {
+			throw IllegalStateException("Other matrix (${other.rows}) has different amount of rows compared to this matrix (${rows})")
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if [other] is not the same amount of rows as this matrix
+	 */
+	fun checkRowsEquals(other: IMatrixLike, lazy: () -> Any) {
+		if (!rowsEquals(other)) {
+			throw IllegalStateException(lazy.invoke().toString())
+		}
+	}
+
+	/**
+	 * @return Whenever [other] has the same amount of columns as this matrix
+	 */
+	fun columnsEquals(other: IMatrixLike): Boolean {
+		return columns == other.columns
+	}
+
+	/**
+	 * @throws IllegalArgumentException if [other] is not the same amount of columns as this matrix
+	 */
+	fun requireColumnsEquals(other: IMatrixLike) {
+		if (!rowsEquals(other)) {
+			throw IllegalArgumentException("Other matrix (${other.columns}) has different amount of columns compared to this matrix (${columns})")
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if [other] is not the same amount of columns as this matrix
+	 */
+	fun requireColumnsEquals(other: IMatrixLike, lazy: () -> Any) {
+		if (!rowsEquals(other)) {
+			throw IllegalArgumentException(lazy.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if [other] is not the same amount of columns as this matrix
+	 */
+	fun checkColumnsEquals(other: IMatrixLike) {
+		if (!rowsEquals(other)) {
+			throw IllegalStateException("Other matrix (${other.columns}) has different amount of columns compared to this matrix (${columns})")
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if [other] is not the same amount of columns as this matrix
+	 */
+	fun checkColumnsEquals(other: IMatrixLike, lazy: () -> Any) {
+		if (!rowsEquals(other)) {
+			throw IllegalStateException(lazy.invoke().toString())
+		}
+	}
+}
+
+interface IMatrixGetterInt : IMatrixLike {
+	/**
+	 * @return component of this matrix, as int
+	 */
+	operator fun get(column: Int, row: Int): Int
+}
+
+interface IMatrixGetterLong : IMatrixLike {
+	/**
+	 * @return component of this matrix, as long
+	 */
+	operator fun get(column: Int, row: Int): Long
+}
+
+interface IMatrixGetterShort : IMatrixLike {
+	/**
+	 * @return component of this matrix, as short
+	 */
+	operator fun get(column: Int, row: Int): Short
+}
+
+interface IMatrixGetterByte : IMatrixLike {
+	/**
+	 * @return component of this matrix, as byte
+	 */
+	operator fun get(column: Int, row: Int): Byte
+}
+
+interface IMatrixSetterInt : IMatrixLike {
+	/**
+	 * Sets component of this matrix, as int
+	 */
+	operator fun set(column: Int, row: Int, value: Int)
+}
+
+interface IMatrixSetterLong : IMatrixLike {
+	/**
+	 * Sets component of this matrix, as long
+	 */
+	operator fun set(column: Int, row: Int, value: Long)
+}
+
+interface IMatrixSetterShort : IMatrixLike {
+	/**
+	 * Sets component of this matrix, as short
+	 */
+	operator fun set(column: Int, row: Int, value: Short)
+}
+
+interface IMatrixSetterByte : IMatrixLike {
+	/**
+	 * Sets component of this matrix, as byte
+	 */
+	operator fun set(column: Int, row: Int, value: Byte)
+}
+
+/**
+ * Root inheritance tree of Matrix classes
+ */
+interface IMatrix<T : IMatrix<T>> : IMatrixLike {
+	/**
+	 * Whenever all components of this matrix are finite
+	 */
+	val isFinite: Boolean
+
+	/**
+	 * Whenever any of components of this matrix are NaN
+	 */
+	val isNaN: Boolean
+
+	/**
+	 * Whenever is this matrix valid (components are not NaN and are finite)
+	 */
+	val isValid: Boolean get() = isFinite && !isNaN
+
+	/**
+	 * @throws IllegalArgumentException if matrix is not finite
+	 */
+	fun requireIsFinite(lambda: () -> Any) {
+		if (!isFinite) {
+			throw IllegalArgumentException(lambda.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if matrix is not finite
+	 */
+	fun requireIsFinite() {
+		if (!isFinite) {
+			throw IllegalArgumentException("Matrix is not finite")
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if matrix is not finite
+	 */
+	fun checkIsFinite(lambda: () -> Any) {
+		if (!isFinite) {
+			throw IllegalStateException(lambda.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if matrix is not finite
+	 */
+	fun checkIsFinite() {
+		if (!isFinite) {
+			throw IllegalStateException("Matrix is not finite")
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if vector has NaN component
+	 */
+	fun requireNotNaN(lambda: () -> Any) {
+		if (isNaN) {
+			throw IllegalArgumentException(lambda.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if matrix has NaN component
+	 */
+	fun requireNotNaN() {
+		if (isNaN) {
+			throw IllegalArgumentException("Matrix has NaN component")
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if matrix has NaN component
+	 */
+	fun checkNotNaN(lambda: () -> Any) {
+		if (!isFinite) {
+			throw IllegalStateException(lambda.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if matrix has NaN component
+	 */
+	fun checkNotNaN() {
+		if (!isFinite) {
+			throw IllegalStateException("Matrix has NaN component")
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if matrix has NaN or infinite component
+	 */
+	fun requireIsValid() {
+		requireIsFinite()
+		requireNotNaN()
+	}
+
+	/**
+	 * @throws IllegalStateException if matrix has NaN or infinite component
+	 */
+	fun checkIsValid() {
+		requireIsFinite()
+		requireNotNaN()
+	}
+
+	/**
+	 * @throws IllegalArgumentException if matrix has NaN or infinite component
+	 */
+	fun requireIsValid(lambda: () -> Any) {
+		requireIsFinite(lambda)
+		requireNotNaN(lambda)
+	}
+
+	/**
+	 * @throws IllegalStateException if matrix has NaN or infinite component
+	 */
+	fun checkIsValid(lambda: () -> Any) {
+		requireIsFinite(lambda)
+		requireNotNaN(lambda)
+	}
+}
+
+
+/**
+ * Marks matrix for being transposable with result of T
+ */
+interface ITransposable<T> {
+	/**
+	 * New matrix, which is transposed variant of this matrix
+	 *
+	 * @return new matrix
+	 */
+	val transposed: T
+}
+
+/**
+ * Marks matrix for being transposable in place
+ */
+interface IMutableTransposable<T> {
+	/**
+	 * Attempts to transpose this matrix, writing the transpose result into itself
+	 *
+	 * @throws IllegalStateException if this matrix is not a square matrix
+	 * @return this matrix
+	 */
+	fun transpose(): T
+}
+
+/**
+ * Getter for matrix complement
+ */
+interface IMatrixComplement<T> {
+	/**
+	 * Constructs a new matrix, representing complement of this matrix at [column] and [row]
+	 *
+	 * @throws IllegalStateException if this matrix is not applicable for complement operation
+	 * @return new matrix, representing minor, with size - 1 of this matrix
+	 */
+	fun complement(column: Int, row: Int): T
+}
+
+/**
+ * Defines common operations with concrete square matrices, such as [translation], [scale]ing, etc
+ */
+interface ISquareMatrix<T : ISquareMatrix<T, V>, V> {
+	/**
+	 * Current translation of this matrix.
+	 */
+	val translation: V
+
+	/**
+	 * Does raw translation of this matrix by specified [vector],
+	 * returning new matrix as result.
+	 *
+	 * If you scaled and/or rotated this matrix, and want to move it
+	 * with scale and translation, use [translateWithMultiplication].
+	 *
+	 * @return new matrix
+	 */
+	fun translate(vector: V): T
+
+	/**
+	 * Does translation of this matrix by specified [vector],
+	 * with accounting of it's state, returning new matrix as result.
+	 *
+	 * @return new matrix
+	 */
+	fun translateWithMultiplication(vector: V): T
+
+	/**
+	 * Multiplies main diagonal of this matrix with [vector],
+	 * returning new matrix as result.
+	 *
+	 * @return new matrix
+	 */
+	fun scale(vector: V): T
+}
+
+/**
+ * Defines common mutable operations with concrete square matrices, such as [translation], [scale]ing, etc
+ */
+interface IMutableSquareMatrix<T : IMutableSquareMatrix<T, V>, V> : ISquareMatrix<T, V> {
+	/**
+	 * Current translation of this matrix.
+	 *
+	 * Writing vector to this property will set raw matrix translation.
+	 */
+	override var translation: V
+
+	/**
+	 * Does translation of this matrix by specified [vector],
+	 * with accounting of it's state, writing result into this matrix.
+	 *
+	 * @return this matrix
+	 */
+	fun translateWithMultiplicationMut(vector: V): T
+
+	/**
+	 * Multiplies main diagonal of this matrix with [vector],
+	 * writing result into this matrix.
+	 *
+	 * @return this matrix
+	 */
+	fun scaleMut(vector: V): T
+}

src/kvector/kotlin/ru/dbotthepony/kvector/api/Struct.kt

@@ -0,0 +1,82 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.api
+
+interface IStruct2f {
+	operator fun component1(): Float
+	operator fun component2(): Float
+}
+
+interface IStruct3f : IStruct2f {
+	operator fun component3(): Float
+}
+
+interface IStruct4f : IStruct3f {
+	operator fun component4(): Float
+}
+
+interface IStruct2d {
+	operator fun component1(): Double
+	operator fun component2(): Double
+}
+
+interface IStruct3d : IStruct2d {
+	operator fun component3(): Double
+}
+
+interface IStruct4d : IStruct3d {
+	operator fun component4(): Double
+}
+
+interface IStruct2i {
+	operator fun component1(): Int
+	operator fun component2(): Int
+}
+
+interface IStruct3i : IStruct2i {
+	operator fun component3(): Int
+}
+
+interface IStruct4i : IStruct3i {
+	operator fun component4(): Int
+}
+
+interface IStruct2l {
+	operator fun component1(): Long
+	operator fun component2(): Long
+}
+
+interface IStruct3l : IStruct2l {
+	operator fun component3(): Long
+}
+
+interface IStruct4l : IStruct3l {
+	operator fun component4(): Long
+}
+
+interface IStruct2s {
+	operator fun component1(): Short
+	operator fun component2(): Short
+}
+
+interface IStruct3s : IStruct2s {
+	operator fun component3(): Short
+}
+
+interface IStruct4s : IStruct3s {
+	operator fun component4(): Short
+}
+
+interface IStruct2b {
+	operator fun component1(): Byte
+	operator fun component2(): Byte
+}
+
+interface IStruct3b : IStruct2b {
+	operator fun component3(): Byte
+}
+
+interface IStruct4b : IStruct3b {
+	operator fun component4(): Byte
+}

src/kvector/kotlin/ru/dbotthepony/kvector/api/Vector.kt

@@ -0,0 +1,433 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.api
+
+import kotlin.math.sqrt
+
+/**
+ * Root interface of vector inheritance tree, providing all relevant methods
+ * of operation on vectors of fixed length
+ */
+interface IVector<T : IVector<T>> {
+	/**
+	 * Length of this vector, as Double
+	 */
+	val length: Double get() = sqrt(lengthSquared)
+
+	/**
+	 * Squared length of this vector, as Double
+	 */
+	val lengthSquared: Double
+
+	/**
+	 * Whenever all components of vector are finite
+	 *
+	 * Keep in mind that in some situations infinite vectors are still making sense
+	 * (e.g. creating [AABB] that cover entire game, or alike, world)
+	 */
+	val isFinite: Boolean
+
+	/**
+	 * Whenever at least one of components of vector are NaN
+	 */
+	val isNaN: Boolean
+
+	/**
+	 * Whenever is this vector valid (components are not NaN and are finite)
+	 *
+	 * Keep in mind that in some situations infinite vectors are still making sense
+	 * (e.g. creating [AABB] that cover entire game, or alike, world)
+	 */
+	val isValid: Boolean get() = isFinite && !isNaN
+
+	/**
+	 * Adds components of both vectors, returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun plus(other: T): T
+
+	/**
+	 * Subtracts components of both vectors, returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun minus(other: T): T
+
+	/**
+	 * Multiplies components of both vectors, returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun times(other: T): T
+
+	/**
+	 * Divides components of both vectors, returning new vector as result
+	 *
+	 * @throws ArithmeticException if vector work with whole numbers, and
+	 * one of [other] components end up zero
+	 *
+	 * @return new vector
+	 */
+	operator fun div(other: T): T
+
+	/**
+	 * New vector, with every component being absolute
+	 */
+	val absoluteValue: T
+
+	/**
+	 * Takes all components of both vectors, and choose the smallest of each,
+	 * and construct a new vector from them
+	 *
+	 * @return new vector
+	 */
+	fun coerceAtMost(maximal: T): T
+
+	/**
+	 * Takes all components of both vectors, and choose the biggest of each,
+	 * and construct a new vector from them
+	 *
+	 * @return new vector
+	 */
+	fun coerceAtLeast(minimal: T): T
+
+	/**
+	 * Takes all components of this vector, and clamp them in between [minimal] and [maximal] corresponding
+	 * components and construct a new vector from them
+	 *
+	 * @return new vector
+	 */
+	fun clamp(minimal: T, maximal: T): T
+
+	/**
+	 * Constructs a new vector with all components negated
+	 *
+	 * @return new vector
+	 */
+	operator fun unaryMinus(): T
+
+	/**
+	 * Returns square rooted distance bewteen this and [other]
+	 *
+	 * @return distance between vectors (as points) as [Double]
+	 */
+	fun distance(other: T): Double {
+		return sqrt(distanceSquared(other))
+	}
+
+	/**
+	 * Returns squared distance between this and [other]
+	 *
+	 * @return distance between vectors (as points) as [Double]
+	 */
+	fun distanceSquared(other: T): Double
+}
+
+/**
+ * Define all relatable methods on vectors which components are fractional
+ */
+interface IFractionalVector<T : IFractionalVector<T>> {
+	/**
+	 * New (directional) vector, with length of 1
+	 *
+	 * If vector length is zero, a zero vector is returned
+	 */
+	val normalized: T
+}
+
+/**
+ * Define all relatable mutating methods on vectors which components are fractional
+ */
+interface IMutableFractionalVector<T : IMutableFractionalVector<T>> {
+	/**
+	 * Normalizes this vector (by setting all of its components) to have 1 unit length
+	 * (turning it into directional or unit vector),
+	 * returning old length as [Double]
+	 *
+	 * @return old length as [Double]
+	 */
+	fun normalize(): Double
+}
+
+/**
+ * Define all relatable methods on vectors which components are whole numbers
+ */
+interface IWholeVector<T : IWholeVector<T>> {
+	/**
+	 * Returns squared distance between this and [other], but as whole number
+	 *
+	 * @return distance between vectors (as points) as [Long]
+	 */
+	fun wholeDistanceSquared(other: T): Long
+}
+
+/**
+ * Define all relatable mutating methods on vectors which components are whole numbers
+ */
+interface IMutableWholeVector<T : IMutableWholeVector<T>> {
+
+}
+
+/**
+ * Define mutable vector x vector operations
+ */
+interface IMutableVector<T : IMutableVector<T, V>, V> {
+	/**
+	 * Adds components of both vectors, setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun plusMut(other: V): T
+
+	/**
+	 * Subtracts components of both vectors, setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun minusMut(other: V): T
+
+	/**
+	 * Multiplies components of both vectors, setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun timesMut(other: V): T
+
+	/**
+	 * Divides components of both vectors, setting result to this vector
+	 *
+	 * @throws ArithmeticException if vector work with whole numbers, and
+	 * one of [other] components end up zero
+	 *
+	 * @return this vector
+	 */
+	fun divMut(other: V): T
+}
+
+/**
+ * Define mutable scalar x vector operations using [Double]s
+ */
+interface IMutableDoubleVector<T : IMutableDoubleVector<T>> {
+	/**
+	 * Multiplies components of vector by [other], setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun timesMut(other: Double): T
+
+	/**
+	 * Divides components of vector by [other], setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun divMut(other: Double): T
+}
+
+/**
+ * Define scalar x vector operations using [Double]s
+ */
+interface IDoubleVector<T : IDoubleVector<T>> {
+	/**
+	 * Multiplies [other] by all components, returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun times(other: Double): T
+
+	/**
+	 * Divides components by [other], returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun div(other: Double): T
+}
+
+/**
+ * Define mutable scalar x vector operations using [Float]s
+ */
+interface IMutableFloatVector<T : IMutableFloatVector<T>> {
+	/**
+	 * Multiplies components of vector by [other], setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun timesMut(other: Float): T
+
+	/**
+	 * Divides components of vector by [other], setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun divMut(other: Float): T
+}
+
+/**
+ * Define scalar x vector operations using [Float]s
+ */
+interface IFloatVector<T : IFloatVector<T>> {
+	/**
+	 * Multiplies [other] by all components, returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun times(other: Float): T
+
+	/**
+	 * Divides components by [other], returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun div(other: Float): T
+}
+
+/**
+ * Define mutable scalar x vector operations using [Int]s
+ */
+interface IMutableIntVector<T : IMutableIntVector<T>> {
+	/**
+	 * Multiplies components of vector by [other], setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun timesMut(other: Int): T
+
+	/**
+	 * Divides components of vector by [other], setting result to this vector
+	 *
+	 * @return this vector
+	 */
+	fun divMut(other: Int): T
+}
+
+/**
+ * Define scalar x vector operations using [Int]s
+ */
+interface IIntVector<T : IIntVector<T>> {
+	/**
+	 * Multiplies [other] by all components, returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun times(other: Int): T
+
+	/**
+	 * Divides components by [other], returning new vector as result
+	 *
+	 * @return new vector
+	 */
+	operator fun div(other: Int): T
+}
+
+/**
+ * Root class of vector inheritance tree, providing some concrete methods
+ * for vectors of fixed length
+ */
+abstract class AbstractVector<T : AbstractVector<T>> : IMatrixLike, IVector<T> {
+	final override val columns: Int = 1
+
+	/**
+	 * @throws IllegalArgumentException if vector is not finite
+	 */
+	inline fun requireIsFinite(lambda: () -> Any) {
+		if (!isFinite) {
+			throw IllegalArgumentException(lambda.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if vector is not finite
+	 */
+	inline fun requireIsFinite() {
+		if (!isFinite) {
+			throw IllegalArgumentException("Vector is not finite")
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if vector is not finite
+	 */
+	inline fun checkIsFinite(lambda: () -> Any) {
+		if (!isFinite) {
+			throw IllegalStateException(lambda.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if vector is not finite
+	 */
+	inline fun checkIsFinite() {
+		if (!isFinite) {
+			throw IllegalStateException("Vector is not finite")
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if vector has NaN component
+	 */
+	inline fun requireNotNaN(lambda: () -> Any) {
+		if (isNaN) {
+			throw IllegalArgumentException(lambda.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if vector has NaN component
+	 */
+	inline fun requireNotNaN() {
+		if (isNaN) {
+			throw IllegalArgumentException("Vector has NaN component")
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if vector has NaN component
+	 */
+	inline fun checkNotNaN(lambda: () -> Any) {
+		if (!isFinite) {
+			throw IllegalStateException(lambda.invoke().toString())
+		}
+	}
+
+	/**
+	 * @throws IllegalStateException if vector has NaN component
+	 */
+	inline fun checkNotNaN() {
+		if (!isFinite) {
+			throw IllegalStateException("Vector has NaN component")
+		}
+	}
+
+	/**
+	 * @throws IllegalArgumentException if vector has NaN or infinite component
+	 */
+	inline fun requireIsValid() {
+		requireIsFinite()
+		requireNotNaN()
+	}
+
+	/**
+	 * @throws IllegalStateException if vector has NaN or infinite component
+	 */
+	inline fun checkIsValid() {
+		requireIsFinite()
+		requireNotNaN()
+	}
+
+	/**
+	 * @throws IllegalArgumentException if vector has NaN or infinite component
+	 */
+	inline fun requireIsValid(lambda: () -> Any) {
+		requireIsFinite(lambda)
+		requireNotNaN(lambda)
+	}
+
+	/**
+	 * @throws IllegalStateException if vector has NaN or infinite component
+	 */
+	inline fun checkIsValid(lambda: () -> Any) {
+		requireIsFinite(lambda)
+		requireNotNaN(lambda)
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/api/concrete/DoubleMatrix.kt

@@ -0,0 +1,166 @@
+package ru.dbotthepony.kvector.api.concrete
+
+import ru.dbotthepony.kvector.api.IDoubleMatrix
+import ru.dbotthepony.kvector.api.IMatrix
+import ru.dbotthepony.kvector.api.ISquareMatrix
+import ru.dbotthepony.kvector.api.ITransposable
+import ru.dbotthepony.kvector.matrix.*
+import ru.dbotthepony.kvector.vector.ndouble.Vector2d
+import ru.dbotthepony.kvector.vector.ndouble.Vector3d
+import ru.dbotthepony.kvector.vector.ndouble.Vector4d
+
+/**
+ * [Matrix2d] and [MutableMatrix2d] implement this
+ */
+interface IMatrix2d<T : IMatrix2d<T>> : IMatrix<T>, IDoubleMatrix<T>, ITransposable<T> {
+	val c00: Double
+	val c10: Double
+	val c01: Double
+	val c11: Double
+	val r00: Double
+	val r01: Double
+	val r10: Double
+	val r11: Double
+	val a11: Double
+	val a21: Double
+	val a12: Double
+	val a22: Double
+	val b11: Double
+	val b21: Double
+	val b12: Double
+	val b22: Double
+	val c0: Vector2d
+	val c1: Vector2d
+	val r0: Vector2d
+	val r1: Vector2d
+}
+
+/**
+ * [Matrix3d] and [MutableMatrix3d] implement this
+ */
+interface IMatrix3d<T : IMatrix3d<T>> : IMatrix<T>, IDoubleMatrix<T>, ITransposable<T>, ISquareMatrix<T, Vector2d> {
+	val c00: Double
+	val c10: Double
+	val c20: Double
+	val c01: Double
+	val c11: Double
+	val c21: Double
+	val c02: Double
+	val c12: Double
+	val c22: Double
+	val r00: Double
+	val r01: Double
+	val r02: Double
+	val r10: Double
+	val r11: Double
+	val r12: Double
+	val r20: Double
+	val r21: Double
+	val r22: Double
+	val a11: Double
+	val a21: Double
+	val a31: Double
+	val a12: Double
+	val a22: Double
+	val a32: Double
+	val a13: Double
+	val a23: Double
+	val a33: Double
+	val b11: Double
+	val b21: Double
+	val b31: Double
+	val b12: Double
+	val b22: Double
+	val b32: Double
+	val b13: Double
+	val b23: Double
+	val b33: Double
+	val c0: Vector3d
+	val c1: Vector3d
+	val c2: Vector3d
+	val r0: Vector3d
+	val r1: Vector3d
+	val r2: Vector3d
+
+	override val translation: Vector2d get() = Vector2d(r02, r12)
+}
+
+/**
+ * [Matrix4d] and [MutableMatrix4d] implement this
+ */
+interface IMatrix4d<T : IMatrix4d<T>> : IMatrix<T>, IDoubleMatrix<T>, ITransposable<T>, ISquareMatrix<T, Vector3d> {
+	val c00: Double
+	val c10: Double
+	val c20: Double
+	val c30: Double
+	val c01: Double
+	val c11: Double
+	val c21: Double
+	val c31: Double
+	val c02: Double
+	val c12: Double
+	val c22: Double
+	val c32: Double
+	val c03: Double
+	val c13: Double
+	val c23: Double
+	val c33: Double
+	val r00: Double
+	val r01: Double
+	val r02: Double
+	val r03: Double
+	val r10: Double
+	val r11: Double
+	val r12: Double
+	val r13: Double
+	val r20: Double
+	val r21: Double
+	val r22: Double
+	val r23: Double
+	val r30: Double
+	val r31: Double
+	val r32: Double
+	val r33: Double
+	val a11: Double
+	val a21: Double
+	val a31: Double
+	val a41: Double
+	val a12: Double
+	val a22: Double
+	val a32: Double
+	val a42: Double
+	val a13: Double
+	val a23: Double
+	val a33: Double
+	val a43: Double
+	val a14: Double
+	val a24: Double
+	val a34: Double
+	val a44: Double
+	val b11: Double
+	val b21: Double
+	val b31: Double
+	val b41: Double
+	val b12: Double
+	val b22: Double
+	val b32: Double
+	val b42: Double
+	val b13: Double
+	val b23: Double
+	val b33: Double
+	val b43: Double
+	val b14: Double
+	val b24: Double
+	val b34: Double
+	val b44: Double
+	val c0: Vector4d
+	val c1: Vector4d
+	val c2: Vector4d
+	val c3: Vector4d
+	val r0: Vector4d
+	val r1: Vector4d
+	val r2: Vector4d
+	val r3: Vector4d
+
+	override val translation: Vector3d get() = Vector3d(r03, r13, r23)
+}

src/kvector/kotlin/ru/dbotthepony/kvector/api/concrete/FloatMatrix.kt

@@ -0,0 +1,167 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.api.concrete
+
+import ru.dbotthepony.kvector.api.IFloatMatrix
+import ru.dbotthepony.kvector.api.IMatrix
+import ru.dbotthepony.kvector.api.ISquareMatrix
+import ru.dbotthepony.kvector.api.ITransposable
+import ru.dbotthepony.kvector.matrix.*
+import ru.dbotthepony.kvector.vector.nfloat.*
+
+/**
+ * [Matrix2f] and [MutableMatrix2f] implement this
+ */
+interface IMatrix2f<T : IMatrix2f<T>> : IMatrix<T>, IFloatMatrix<T>, ITransposable<T> {
+	val c00: Float
+	val c10: Float
+	val c01: Float
+	val c11: Float
+	val r00: Float
+	val r01: Float
+	val r10: Float
+	val r11: Float
+	val a11: Float
+	val a21: Float
+	val a12: Float
+	val a22: Float
+	val b11: Float
+	val b21: Float
+	val b12: Float
+	val b22: Float
+	val c0: Vector2f
+	val c1: Vector2f
+	val r0: Vector2f
+	val r1: Vector2f
+}
+
+/**
+ * [Matrix3f] and [MutableMatrix3f] implement this
+ */
+interface IMatrix3f<T : IMatrix3f<T>> : IMatrix<T>, IFloatMatrix<T>, ITransposable<T>, ISquareMatrix<T, Vector2f> {
+	val c00: Float
+	val c10: Float
+	val c20: Float
+	val c01: Float
+	val c11: Float
+	val c21: Float
+	val c02: Float
+	val c12: Float
+	val c22: Float
+	val r00: Float
+	val r01: Float
+	val r02: Float
+	val r10: Float
+	val r11: Float
+	val r12: Float
+	val r20: Float
+	val r21: Float
+	val r22: Float
+	val a11: Float
+	val a21: Float
+	val a31: Float
+	val a12: Float
+	val a22: Float
+	val a32: Float
+	val a13: Float
+	val a23: Float
+	val a33: Float
+	val b11: Float
+	val b21: Float
+	val b31: Float
+	val b12: Float
+	val b22: Float
+	val b32: Float
+	val b13: Float
+	val b23: Float
+	val b33: Float
+	val c0: Vector3f
+	val c1: Vector3f
+	val c2: Vector3f
+	val r0: Vector3f
+	val r1: Vector3f
+	val r2: Vector3f
+
+	override val translation: Vector2f get() = Vector2f(r02, r12)
+}
+
+/**
+ * [Matrix4f] and [MutableMatrix4f] implement this
+ */
+interface IMatrix4f<T : IMatrix4f<T>> : IMatrix<T>, IFloatMatrix<T>, ITransposable<T>, ISquareMatrix<T, Vector3f> {
+	val c00: Float
+	val c10: Float
+	val c20: Float
+	val c30: Float
+	val c01: Float
+	val c11: Float
+	val c21: Float
+	val c31: Float
+	val c02: Float
+	val c12: Float
+	val c22: Float
+	val c32: Float
+	val c03: Float
+	val c13: Float
+	val c23: Float
+	val c33: Float
+	val r00: Float
+	val r01: Float
+	val r02: Float
+	val r03: Float
+	val r10: Float
+	val r11: Float
+	val r12: Float
+	val r13: Float
+	val r20: Float
+	val r21: Float
+	val r22: Float
+	val r23: Float
+	val r30: Float
+	val r31: Float
+	val r32: Float
+	val r33: Float
+	val a11: Float
+	val a21: Float
+	val a31: Float
+	val a41: Float
+	val a12: Float
+	val a22: Float
+	val a32: Float
+	val a42: Float
+	val a13: Float
+	val a23: Float
+	val a33: Float
+	val a43: Float
+	val a14: Float
+	val a24: Float
+	val a34: Float
+	val a44: Float
+	val b11: Float
+	val b21: Float
+	val b31: Float
+	val b41: Float
+	val b12: Float
+	val b22: Float
+	val b32: Float
+	val b42: Float
+	val b13: Float
+	val b23: Float
+	val b33: Float
+	val b43: Float
+	val b14: Float
+	val b24: Float
+	val b34: Float
+	val b44: Float
+	val c0: Vector4f
+	val c1: Vector4f
+	val c2: Vector4f
+	val c3: Vector4f
+	val r0: Vector4f
+	val r1: Vector4f
+	val r2: Vector4f
+	val r3: Vector4f
+
+	override val translation: Vector3f get() = Vector3f(r03, r13, r23)
+}

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/functions.kt

@@ -0,0 +1,521 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.matrix
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.matrix.generated.*
+import ru.dbotthepony.kvector.matrix.generated.matrixConcreteDeterminant
+import ru.dbotthepony.kvector.narray.*
+import kotlin.math.pow
+
+/**
+ * Multiplies matrices as long as they are compatible, of any size.
+ * Attempts to use concrete implementation first.
+ *
+ * @throws IllegalArgumentException if matrices are incompatible
+ *
+ * @return new [Double2Dimensional] buffer with multiplication result
+ */
+fun multiplyMatrix(matrix1: IMatrixGetterDouble, matrix2: IMatrixGetterDouble): Double2Dimensional {
+	require(matrix1.columns == matrix2.rows) { "Matrices are incompatible for multiplication (Matrix 1 has ${matrix1.columns} columns, Matrix 2 has ${matrix2.rows} rows)" }
+
+	val multiplied = MultiplicationsDouble.multiplyMatrix(matrix1, matrix2)
+
+	if (multiplied != null) {
+		return multiplied
+	}
+
+	val resultRows = matrix1.rows
+	val resultColumns = matrix2.columns
+	val vectorized = matrix1.columns
+
+	val output = Double2Dimensional(resultColumns, resultRows)
+
+	for (row in 0 until resultRows) {
+		for (column in 0 until resultColumns) {
+			var sum = 0.0
+
+			for (rowColumn in 0 until vectorized) {
+				sum += matrix1[row, rowColumn] * matrix2[rowColumn, column]
+			}
+
+			output[row, column] = sum
+		}
+	}
+
+	return output
+}
+
+/**
+ * Multiplies matrices as long as they are compatible, of any size.
+ * Attempts to use concrete implementation first.
+ *
+ * @throws IllegalArgumentException if matrices are incompatible
+ *
+ * @return new [Float2Dimensional] buffer with multiplication result
+ */
+fun multiplyMatrix(matrix1: IMatrixGetterFloat, matrix2: IMatrixGetterFloat): Float2Dimensional {
+	require(matrix1.columns == matrix2.rows) { "Matrices are incompatible for multiplication (Matrix 1 has ${matrix1.columns} columns, Matrix 2 has ${matrix2.rows} rows)" }
+
+	val multiplied = MultiplicationsFloat.multiplyMatrix(matrix1, matrix2)
+
+	if (multiplied != null) {
+		return multiplied
+	}
+
+	val resultRows = matrix1.rows
+	val resultColumns = matrix2.columns
+	val vectorized = matrix1.columns
+
+	val output = Float2Dimensional(resultColumns, resultRows)
+
+	for (row in 0 until resultRows) {
+		for (column in 0 until resultColumns) {
+			var sum = 0f
+
+			for (rowColumn in 0 until vectorized) {
+				sum += matrix1[row, rowColumn] * matrix2[rowColumn, column]
+			}
+
+			output[row, column] = sum
+		}
+	}
+
+	return output
+}
+
+/**
+ * Multiplies matrices as long as they are compatible, of any size.
+ * Attempts to use concrete implementation first.
+ *
+ * @throws IllegalArgumentException if matrices are incompatible
+ *
+ * @return new [Int2Dimensional] buffer with multiplication result
+ */
+fun multiplyMatrix(matrix1: IMatrixGetterInt, matrix2: IMatrixGetterInt): Int2Dimensional {
+	require(matrix1.columns == matrix2.rows) { "Matrices are incompatible for multiplication (Matrix 1 has ${matrix1.columns} columns, Matrix 2 has ${matrix2.rows} rows)" }
+
+	val multiplied = MultiplicationsInt.multiplyMatrix(matrix1, matrix2)
+
+	if (multiplied != null) {
+		return multiplied
+	}
+
+	val resultRows = matrix1.rows
+	val resultColumns = matrix2.columns
+	val vectorized = matrix1.columns
+
+	val output = Int2Dimensional(resultColumns, resultRows)
+
+	for (row in 0 until resultRows) {
+		for (column in 0 until resultColumns) {
+			var sum = 0
+
+			for (rowColumn in 0 until vectorized) {
+				sum += matrix1[row, rowColumn] * matrix2[rowColumn, column]
+			}
+
+			output[row, column] = sum
+		}
+	}
+
+	return output
+}
+
+/**
+ * Multiplies matrices as long as they are compatible, of any size.
+ * Attempts to use concrete implementation first.
+ *
+ * @throws IllegalArgumentException if matrices are incompatible
+ *
+ * @return new [Long2Dimensional] buffer with multiplication result
+ */
+fun multiplyMatrix(matrix1: IMatrixGetterLong, matrix2: IMatrixGetterLong): Long2Dimensional {
+	require(matrix1.columns == matrix2.rows) { "Matrices are incompatible for multiplication (Matrix 1 has ${matrix1.columns} columns, Matrix 2 has ${matrix2.rows} rows)" }
+
+	val multiplied = MultiplicationsLong.multiplyMatrix(matrix1, matrix2)
+
+	if (multiplied != null) {
+		return multiplied
+	}
+
+	val resultRows = matrix1.rows
+	val resultColumns = matrix2.columns
+	val vectorized = matrix1.columns
+
+	val output = Long2Dimensional(resultColumns, resultRows)
+
+	for (row in 0 until resultRows) {
+		for (column in 0 until resultColumns) {
+			var sum = 0L
+
+			for (rowColumn in 0 until vectorized) {
+				sum += matrix1[row, rowColumn] * matrix2[rowColumn, column]
+			}
+
+			output[row, column] = sum
+		}
+	}
+
+	return output
+}
+
+/**
+ * Multiplies matrices as long as they are compatible, of any size.
+ * Attempts to use concrete implementation first.
+ *
+ * @throws IllegalArgumentException if matrices are incompatible
+ *
+ * @return new [Short2Dimensional] buffer with multiplication result
+ */
+fun multiplyMatrix(matrix1: IMatrixGetterShort, matrix2: IMatrixGetterShort): Short2Dimensional {
+	require(matrix1.columns == matrix2.rows) { "Matrices are incompatible for multiplication (Matrix 1 has ${matrix1.columns} columns, Matrix 2 has ${matrix2.rows} rows)" }
+
+	val multiplied = MultiplicationsShort.multiplyMatrix(matrix1, matrix2)
+
+	if (multiplied != null) {
+		return multiplied
+	}
+
+	val resultRows = matrix1.rows
+	val resultColumns = matrix2.columns
+	val vectorized = matrix1.columns
+
+	val output = Short2Dimensional(resultColumns, resultRows)
+
+	for (row in 0 until resultRows) {
+		for (column in 0 until resultColumns) {
+			var sum = 0
+
+			for (rowColumn in 0 until vectorized) {
+				sum += matrix1[row, rowColumn] * matrix2[rowColumn, column]
+			}
+
+			output[row, column] = sum.toShort()
+		}
+	}
+
+	return output
+}
+
+/**
+ * Multiplies matrices as long as they are compatible, of any size.
+ * Attempts to use concrete implementation first.
+ *
+ * @throws IllegalArgumentException if matrices are incompatible
+ *
+ * @return new [Byte2Dimensional] buffer with multiplication result
+ */
+fun multiplyMatrix(matrix1: IMatrixGetterByte, matrix2: IMatrixGetterByte): Byte2Dimensional {
+	require(matrix1.columns == matrix2.rows) { "Matrices are incompatible for multiplication (Matrix 1 has ${matrix1.columns} columns, Matrix 2 has ${matrix2.rows} rows)" }
+
+	val multiplied = MultiplicationsByte.multiplyMatrix(matrix1, matrix2)
+
+	if (multiplied != null) {
+		return multiplied
+	}
+
+	val resultRows = matrix1.rows
+	val resultColumns = matrix2.columns
+	val vectorized = matrix1.columns
+
+	val output = Byte2Dimensional(resultColumns, resultRows)
+
+	for (row in 0 until resultRows) {
+		for (column in 0 until resultColumns) {
+			var sum = 0L
+
+			for (rowColumn in 0 until vectorized) {
+				sum += matrix1[row, rowColumn] * matrix2[rowColumn, column]
+			}
+
+			output[row, column] = sum.toByte()
+		}
+	}
+
+	return output
+}
+
+/**
+ * Transposes structure representing matrix of any size.
+ */
+fun transposeMatrix(matrix: IMatrixGetterDouble): Double2Dimensional {
+	val output = Double2Dimensional(matrix.rows, matrix.columns)
+
+	for (column in 0 until matrix.columns) {
+		for (row in 0 until matrix.rows) {
+			output[row, column] = matrix[column, row]
+		}
+	}
+
+	return output
+}
+
+/**
+ * Transposes structure representing matrix of any size.
+ */
+fun transposeMatrix(matrix: IMatrixGetterFloat): Float2Dimensional {
+	val output = Float2Dimensional(matrix.rows, matrix.columns)
+
+	for (column in 0 until matrix.columns) {
+		for (row in 0 until matrix.rows) {
+			output[row, column] = matrix[column, row]
+		}
+	}
+
+	return output
+}
+
+private fun load(matrix: IMatrixGetterDouble, buffers: Array<Double2Dimensional>): Double2Dimensional {
+	val buffer = buffers[matrix.columns - 1]
+
+	for (column in 0 until matrix.columns) {
+		for (row in 0 until matrix.rows) {
+			buffer[column, row] = matrix[column, row]
+		}
+	}
+
+	return buffer
+}
+
+private fun load(matrix: IMatrixGetterFloat, buffers: Array<Float2Dimensional>): Float2Dimensional {
+	val buffer = buffers[matrix.columns - 1]
+
+	for (column in 0 until matrix.columns) {
+		for (row in 0 until matrix.rows) {
+			buffer[column, row] = matrix[column, row]
+		}
+	}
+
+	return buffer
+}
+
+private fun load(matrix: IMatrixGetterInt, buffers: Array<Int2Dimensional>): Int2Dimensional {
+	val buffer = buffers[matrix.columns - 1]
+
+	for (column in 0 until matrix.columns) {
+		for (row in 0 until matrix.rows) {
+			buffer[column, row] = matrix[column, row]
+		}
+	}
+
+	return buffer
+}
+
+private fun load(matrix: IMatrixGetterLong, buffers: Array<Long2Dimensional>): Long2Dimensional {
+	val buffer = buffers[matrix.columns - 1]
+
+	for (column in 0 until matrix.columns) {
+		for (row in 0 until matrix.rows) {
+			buffer[column, row] = matrix[column, row]
+		}
+	}
+
+	return buffer
+}
+
+/**
+ * Constructs new complement matrix from [input] representing square matrix, by taking out [column] and [row], and load result into [buffer].
+ *
+ * @throws IllegalArgumentException if [column] or [row] is out of bounds, or if [input] does not represent a square matrix
+ *
+ * @return [buffer]
+ */
+fun complementMatrix(input: IMatrixGetterDouble, column: Int, row: Int, buffer: Double2Dimensional): Double2Dimensional {
+	require(input.rows == input.columns) { "Provided matrix is not square matrix (${input.rows} rows, ${input.columns} columns)" }
+	require(column < input.columns) { "$column < ${input.columns}" }
+	require(row < input.rows) { "$row < ${input.rows}" }
+
+	var iRow = 0
+	var iColumn = 0
+
+	for (gColumn in 0 until input.columns) {
+		if (gColumn == column)
+			continue
+
+		for (gRow in 0 until input.rows) {
+			if (gRow == row)
+				continue
+
+			buffer[iColumn, iRow++] = input[gColumn, gRow]
+		}
+
+		iColumn++
+		iRow = 0
+	}
+
+	return buffer
+}
+
+/**
+ * Constructs new complement matrix from [input] representing square matrix, by taking out [column] and [row], and load result into [buffer].
+ *
+ * @throws IllegalArgumentException if [column] or [row] is out of bounds, or if [input] does not represent a square matrix
+ *
+ * @return [buffer]
+ */
+fun complementMatrix(input: IMatrixGetterFloat, column: Int, row: Int, buffer: Float2Dimensional): Float2Dimensional {
+	require(input.rows == input.columns) { "Provided matrix is not square matrix (${input.rows} rows, ${input.columns} columns)" }
+	require(column < input.columns) { "$column < ${input.columns}" }
+	require(row < input.rows) { "$row < ${input.rows}" }
+
+	var iRow = 0
+	var iColumn = 0
+
+	for (gColumn in 0 until input.columns) {
+		if (gColumn == column)
+			continue
+
+		for (gRow in 0 until input.rows) {
+			if (gRow == row)
+				continue
+
+			buffer[iColumn, iRow++] = input[gColumn, gRow]
+		}
+
+		iColumn++
+		iRow = 0
+	}
+
+	return buffer
+}
+
+/**
+ * Constructs new complement matrix from [input] representing square matrix, by taking out [column] and [row], and load result into [buffer].
+ *
+ * @throws IllegalArgumentException if [column] or [row] is out of bounds, or if [input] does not represent a square matrix
+ *
+ * @return [buffer]
+ */
+fun complementMatrix(input: IMatrixGetterInt, column: Int, row: Int, buffer: Int2Dimensional): Int2Dimensional {
+	require(input.rows == input.columns) { "Provided matrix is not square matrix (${input.rows} rows, ${input.columns} columns)" }
+	require(column < input.columns) { "$column < ${input.columns}" }
+	require(row < input.rows) { "$row < ${input.rows}" }
+
+	var iRow = 0
+	var iColumn = 0
+
+	for (gColumn in 0 until input.columns) {
+		if (gColumn == column)
+			continue
+
+		for (gRow in 0 until input.rows) {
+			if (gRow == row)
+				continue
+
+			buffer[iColumn, iRow++] = input[gColumn, gRow]
+		}
+
+		iColumn++
+		iRow = 0
+	}
+
+	return buffer
+}
+
+/**
+ * Constructs new complement matrix from [input] representing square matrix, by taking out [column] and [row], and load result into [buffer].
+ *
+ * @throws IllegalArgumentException if [column] or [row] is out of bounds, or if [input] does not represent a square matrix
+ *
+ * @return [buffer]
+ */
+fun complementMatrix(input: IMatrixGetterLong, column: Int, row: Int, buffer: Long2Dimensional): Long2Dimensional {
+	require(input.rows == input.columns) { "Provided matrix is not square matrix (${input.rows} rows, ${input.columns} columns)" }
+	require(column < input.columns) { "$column < ${input.columns}" }
+	require(row < input.rows) { "$row < ${input.rows}" }
+
+	var iRow = 0
+	var iColumn = 0
+
+	for (gColumn in 0 until input.columns) {
+		if (gColumn == column)
+			continue
+
+		for (gRow in 0 until input.rows) {
+			if (gRow == row)
+				continue
+
+			buffer[iColumn, iRow++] = input[gColumn, gRow]
+		}
+
+		iColumn++
+		iRow = 0
+	}
+
+	return buffer
+}
+
+private fun matrixDeterminant(input: Double2Dimensional, size: Int, buffers: Array<Double2Dimensional>): Double {
+	val concrete = matrixConcreteDeterminant(input)
+
+	if (concrete != null) {
+		return concrete
+	}
+
+	var result = 0.0
+
+	for (column in 0 until size) {
+		val minor = matrixDeterminant(complementMatrix(input, column, 0, buffers[input.columns - 2]), size - 1, buffers)
+		val cofactor = (-1.0).pow(2 + column) * minor
+		result += input[column, 0] * cofactor
+	}
+
+	return result
+}
+
+/**
+ * Recursive determinant finder of specified structure representing square matrix.
+ *
+ * @throws IllegalArgumentException if [matrix] structure is not square matrix
+ */
+fun matrixDeterminant(matrix: IMatrixGetterDouble): Double {
+	require(matrix.rows == matrix.columns) { "Provided matrix is not square matrix (${matrix.rows} rows, ${matrix.columns} columns)" }
+
+	val concrete = matrixConcreteDeterminant(matrix)
+
+	if (concrete != null) {
+		return concrete
+	}
+
+	val buffers = Array(matrix.rows) { Double2Dimensional(it + 1, it + 1) }
+	return matrixDeterminant(load(matrix, buffers), matrix.columns, buffers)
+}
+
+private fun matrixDeterminant(input: Float2Dimensional, size: Int, buffers: Array<Float2Dimensional>): Float {
+	val concrete = matrixConcreteDeterminant(input)
+
+	if (concrete != null) {
+		return concrete
+	}
+
+	var result = 0f
+
+	for (column in 0 until size) {
+		val minor = matrixDeterminant(complementMatrix(input, column, 0, buffers[input.columns - 2]), size - 1, buffers)
+		val cofactor = (-1f).pow(2 + column) * minor
+		result += input[column, 0] * cofactor
+	}
+
+	return result
+}
+
+/**
+ * Recursive determinant finder of specified structure representing square matrix.
+ *
+ * @throws IllegalArgumentException if [matrix] structure is not square matrix
+ */
+fun matrixDeterminant(matrix: IMatrixGetterFloat): Float {
+	require(matrix.rows == matrix.columns) { "Provided matrix is not square matrix (${matrix.rows} rows, ${matrix.columns} columns)" }
+
+	val concrete = matrixConcreteDeterminant(matrix)
+
+	if (concrete != null) {
+		return concrete
+	}
+
+	val buffers = Array(matrix.rows) { Float2Dimensional(it + 1, it + 1) }
+	return matrixDeterminant(load(matrix, buffers), matrix.columns, buffers).toFloat()
+}
+

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/generated/DeterminantsByte.kt

@@ -0,0 +1,94 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.matrix.generated
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.narray.*
+
+// Some metaprogramming
+
+private fun determinant2(matrix: IMatrixGetterByte): Byte {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	return (c00*c11 - c01*c10).toByte()
+}
+
+private fun determinant3(matrix: IMatrixGetterByte): Byte {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	return (c00*c11*c22 - c00*c12*c21 - c01*c10*c22 + c01*c12*c20 + c02*c10*c21 - c02*c11*c20).toByte()
+}
+
+private fun determinant4(matrix: IMatrixGetterByte): Byte {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	return (c00*c11*c22*c33 - c00*c11*c23*c32 - c00*c12*c21*c33 + c00*c12*c23*c31 + c00*c13*c21*c32 - c00*c13*c22*c31 - c01*c10*c22*c33 + c01*c10*c23*c32 + c01*c12*c20*c33 - c01*c12*c23*c30 - c01*c13*c20*c32 + c01*c13*c22*c30 + c02*c10*c21*c33 - c02*c10*c23*c31 - c02*c11*c20*c33 + c02*c11*c23*c30 + c02*c13*c20*c31 - c02*c13*c21*c30 - c03*c10*c21*c32 + c03*c10*c22*c31 + c03*c11*c20*c32 - c03*c11*c22*c30 - c03*c12*c20*c31 + c03*c12*c21*c30).toByte()
+}
+
+private fun determinant5(matrix: IMatrixGetterByte): Byte {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c40 = matrix[4, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c41 = matrix[4, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c42 = matrix[4, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	val c43 = matrix[4, 3]
+	val c04 = matrix[0, 4]
+	val c14 = matrix[1, 4]
+	val c24 = matrix[2, 4]
+	val c34 = matrix[3, 4]
+	val c44 = matrix[4, 4]
+	return (c00*c11*c22*c33*c44 - c00*c11*c22*c34*c43 - c00*c11*c23*c32*c44 + c00*c11*c23*c34*c42 + c00*c11*c24*c32*c43 - c00*c11*c24*c33*c42 - c00*c12*c21*c33*c44 + c00*c12*c21*c34*c43 + c00*c12*c23*c31*c44 - c00*c12*c23*c34*c41 - c00*c12*c24*c31*c43 + c00*c12*c24*c33*c41 + c00*c13*c21*c32*c44 - c00*c13*c21*c34*c42 - c00*c13*c22*c31*c44 + c00*c13*c22*c34*c41 + c00*c13*c24*c31*c42 - c00*c13*c24*c32*c41 - c00*c14*c21*c32*c43 + c00*c14*c21*c33*c42 + c00*c14*c22*c31*c43 - c00*c14*c22*c33*c41 - c00*c14*c23*c31*c42 + c00*c14*c23*c32*c41 - c01*c10*c22*c33*c44 + c01*c10*c22*c34*c43 + c01*c10*c23*c32*c44 - c01*c10*c23*c34*c42 - c01*c10*c24*c32*c43 + c01*c10*c24*c33*c42 + c01*c12*c20*c33*c44 - c01*c12*c20*c34*c43 - c01*c12*c23*c30*c44 + c01*c12*c23*c34*c40 + c01*c12*c24*c30*c43 - c01*c12*c24*c33*c40 - c01*c13*c20*c32*c44 + c01*c13*c20*c34*c42 + c01*c13*c22*c30*c44 - c01*c13*c22*c34*c40 - c01*c13*c24*c30*c42 + c01*c13*c24*c32*c40 + c01*c14*c20*c32*c43 - c01*c14*c20*c33*c42 - c01*c14*c22*c30*c43 + c01*c14*c22*c33*c40 + c01*c14*c23*c30*c42 - c01*c14*c23*c32*c40 + c02*c10*c21*c33*c44 - c02*c10*c21*c34*c43 - c02*c10*c23*c31*c44 + c02*c10*c23*c34*c41 + c02*c10*c24*c31*c43 - c02*c10*c24*c33*c41 - c02*c11*c20*c33*c44 + c02*c11*c20*c34*c43 + c02*c11*c23*c30*c44 - c02*c11*c23*c34*c40 - c02*c11*c24*c30*c43 + c02*c11*c24*c33*c40 + c02*c13*c20*c31*c44 - c02*c13*c20*c34*c41 - c02*c13*c21*c30*c44 + c02*c13*c21*c34*c40 + c02*c13*c24*c30*c41 - c02*c13*c24*c31*c40 - c02*c14*c20*c31*c43 + c02*c14*c20*c33*c41 + c02*c14*c21*c30*c43 - c02*c14*c21*c33*c40 - c02*c14*c23*c30*c41 + c02*c14*c23*c31*c40 - c03*c10*c21*c32*c44 + c03*c10*c21*c34*c42 + c03*c10*c22*c31*c44 - c03*c10*c22*c34*c41 - c03*c10*c24*c31*c42 + c03*c10*c24*c32*c41 + c03*c11*c20*c32*c44 - c03*c11*c20*c34*c42 - c03*c11*c22*c30*c44 + c03*c11*c22*c34*c40 + c03*c11*c24*c30*c42 - c03*c11*c24*c32*c40 - c03*c12*c20*c31*c44 + c03*c12*c20*c34*c41 + c03*c12*c21*c30*c44 - c03*c12*c21*c34*c40 - c03*c12*c24*c30*c41 + c03*c12*c24*c31*c40 + c03*c14*c20*c31*c42 - c03*c14*c20*c32*c41 - c03*c14*c21*c30*c42 + c03*c14*c21*c32*c40 + c03*c14*c22*c30*c41 - c03*c14*c22*c31*c40 + c04*c10*c21*c32*c43 - c04*c10*c21*c33*c42 - c04*c10*c22*c31*c43 + c04*c10*c22*c33*c41 + c04*c10*c23*c31*c42 - c04*c10*c23*c32*c41 - c04*c11*c20*c32*c43 + c04*c11*c20*c33*c42 + c04*c11*c22*c30*c43 - c04*c11*c22*c33*c40 - c04*c11*c23*c30*c42 + c04*c11*c23*c32*c40 + c04*c12*c20*c31*c43 - c04*c12*c20*c33*c41 - c04*c12*c21*c30*c43 + c04*c12*c21*c33*c40 + c04*c12*c23*c30*c41 - c04*c12*c23*c31*c40 - c04*c13*c20*c31*c42 + c04*c13*c20*c32*c41 + c04*c13*c21*c30*c42 - c04*c13*c21*c32*c40 - c04*c13*c22*c30*c41 + c04*c13*c22*c31*c40).toByte()
+}
+
+/**
+ * Automatically generated concrete matrix determinant finder. If no mapping exist, this function returns null
+ */
+fun matrixConcreteDeterminant(matrix: IMatrixGetterByte): Byte? {
+	require(matrix.columns == matrix.rows) { "Provided matrix (${matrix.columns}x${matrix.rows}) is not a square matrix" }
+	return when (matrix.columns) {
+		2 -> determinant2(matrix)
+		3 -> determinant3(matrix)
+		4 -> determinant4(matrix)
+		5 -> determinant5(matrix)
+		else -> null
+	}
+}
+

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/generated/DeterminantsDouble.kt

@@ -0,0 +1,94 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.matrix.generated
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.narray.*
+
+// Some metaprogramming
+
+private fun determinant2(matrix: IMatrixGetterDouble): Double {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	return c00*c11 - c01*c10
+}
+
+private fun determinant3(matrix: IMatrixGetterDouble): Double {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	return c00*c11*c22 - c00*c12*c21 - c01*c10*c22 + c01*c12*c20 + c02*c10*c21 - c02*c11*c20
+}
+
+private fun determinant4(matrix: IMatrixGetterDouble): Double {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	return c00*c11*c22*c33 - c00*c11*c23*c32 - c00*c12*c21*c33 + c00*c12*c23*c31 + c00*c13*c21*c32 - c00*c13*c22*c31 - c01*c10*c22*c33 + c01*c10*c23*c32 + c01*c12*c20*c33 - c01*c12*c23*c30 - c01*c13*c20*c32 + c01*c13*c22*c30 + c02*c10*c21*c33 - c02*c10*c23*c31 - c02*c11*c20*c33 + c02*c11*c23*c30 + c02*c13*c20*c31 - c02*c13*c21*c30 - c03*c10*c21*c32 + c03*c10*c22*c31 + c03*c11*c20*c32 - c03*c11*c22*c30 - c03*c12*c20*c31 + c03*c12*c21*c30
+}
+
+private fun determinant5(matrix: IMatrixGetterDouble): Double {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c40 = matrix[4, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c41 = matrix[4, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c42 = matrix[4, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	val c43 = matrix[4, 3]
+	val c04 = matrix[0, 4]
+	val c14 = matrix[1, 4]
+	val c24 = matrix[2, 4]
+	val c34 = matrix[3, 4]
+	val c44 = matrix[4, 4]
+	return c00*c11*c22*c33*c44 - c00*c11*c22*c34*c43 - c00*c11*c23*c32*c44 + c00*c11*c23*c34*c42 + c00*c11*c24*c32*c43 - c00*c11*c24*c33*c42 - c00*c12*c21*c33*c44 + c00*c12*c21*c34*c43 + c00*c12*c23*c31*c44 - c00*c12*c23*c34*c41 - c00*c12*c24*c31*c43 + c00*c12*c24*c33*c41 + c00*c13*c21*c32*c44 - c00*c13*c21*c34*c42 - c00*c13*c22*c31*c44 + c00*c13*c22*c34*c41 + c00*c13*c24*c31*c42 - c00*c13*c24*c32*c41 - c00*c14*c21*c32*c43 + c00*c14*c21*c33*c42 + c00*c14*c22*c31*c43 - c00*c14*c22*c33*c41 - c00*c14*c23*c31*c42 + c00*c14*c23*c32*c41 - c01*c10*c22*c33*c44 + c01*c10*c22*c34*c43 + c01*c10*c23*c32*c44 - c01*c10*c23*c34*c42 - c01*c10*c24*c32*c43 + c01*c10*c24*c33*c42 + c01*c12*c20*c33*c44 - c01*c12*c20*c34*c43 - c01*c12*c23*c30*c44 + c01*c12*c23*c34*c40 + c01*c12*c24*c30*c43 - c01*c12*c24*c33*c40 - c01*c13*c20*c32*c44 + c01*c13*c20*c34*c42 + c01*c13*c22*c30*c44 - c01*c13*c22*c34*c40 - c01*c13*c24*c30*c42 + c01*c13*c24*c32*c40 + c01*c14*c20*c32*c43 - c01*c14*c20*c33*c42 - c01*c14*c22*c30*c43 + c01*c14*c22*c33*c40 + c01*c14*c23*c30*c42 - c01*c14*c23*c32*c40 + c02*c10*c21*c33*c44 - c02*c10*c21*c34*c43 - c02*c10*c23*c31*c44 + c02*c10*c23*c34*c41 + c02*c10*c24*c31*c43 - c02*c10*c24*c33*c41 - c02*c11*c20*c33*c44 + c02*c11*c20*c34*c43 + c02*c11*c23*c30*c44 - c02*c11*c23*c34*c40 - c02*c11*c24*c30*c43 + c02*c11*c24*c33*c40 + c02*c13*c20*c31*c44 - c02*c13*c20*c34*c41 - c02*c13*c21*c30*c44 + c02*c13*c21*c34*c40 + c02*c13*c24*c30*c41 - c02*c13*c24*c31*c40 - c02*c14*c20*c31*c43 + c02*c14*c20*c33*c41 + c02*c14*c21*c30*c43 - c02*c14*c21*c33*c40 - c02*c14*c23*c30*c41 + c02*c14*c23*c31*c40 - c03*c10*c21*c32*c44 + c03*c10*c21*c34*c42 + c03*c10*c22*c31*c44 - c03*c10*c22*c34*c41 - c03*c10*c24*c31*c42 + c03*c10*c24*c32*c41 + c03*c11*c20*c32*c44 - c03*c11*c20*c34*c42 - c03*c11*c22*c30*c44 + c03*c11*c22*c34*c40 + c03*c11*c24*c30*c42 - c03*c11*c24*c32*c40 - c03*c12*c20*c31*c44 + c03*c12*c20*c34*c41 + c03*c12*c21*c30*c44 - c03*c12*c21*c34*c40 - c03*c12*c24*c30*c41 + c03*c12*c24*c31*c40 + c03*c14*c20*c31*c42 - c03*c14*c20*c32*c41 - c03*c14*c21*c30*c42 + c03*c14*c21*c32*c40 + c03*c14*c22*c30*c41 - c03*c14*c22*c31*c40 + c04*c10*c21*c32*c43 - c04*c10*c21*c33*c42 - c04*c10*c22*c31*c43 + c04*c10*c22*c33*c41 + c04*c10*c23*c31*c42 - c04*c10*c23*c32*c41 - c04*c11*c20*c32*c43 + c04*c11*c20*c33*c42 + c04*c11*c22*c30*c43 - c04*c11*c22*c33*c40 - c04*c11*c23*c30*c42 + c04*c11*c23*c32*c40 + c04*c12*c20*c31*c43 - c04*c12*c20*c33*c41 - c04*c12*c21*c30*c43 + c04*c12*c21*c33*c40 + c04*c12*c23*c30*c41 - c04*c12*c23*c31*c40 - c04*c13*c20*c31*c42 + c04*c13*c20*c32*c41 + c04*c13*c21*c30*c42 - c04*c13*c21*c32*c40 - c04*c13*c22*c30*c41 + c04*c13*c22*c31*c40
+}
+
+/**
+ * Automatically generated concrete matrix determinant finder. If no mapping exist, this function returns null
+ */
+fun matrixConcreteDeterminant(matrix: IMatrixGetterDouble): Double? {
+	require(matrix.columns == matrix.rows) { "Provided matrix (${matrix.columns}x${matrix.rows}) is not a square matrix" }
+	return when (matrix.columns) {
+		2 -> determinant2(matrix)
+		3 -> determinant3(matrix)
+		4 -> determinant4(matrix)
+		5 -> determinant5(matrix)
+		else -> null
+	}
+}
+

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/generated/DeterminantsFloat.kt

@@ -0,0 +1,94 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.matrix.generated
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.narray.*
+
+// Some metaprogramming
+
+private fun determinant2(matrix: IMatrixGetterFloat): Float {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	return c00*c11 - c01*c10
+}
+
+private fun determinant3(matrix: IMatrixGetterFloat): Float {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	return c00*c11*c22 - c00*c12*c21 - c01*c10*c22 + c01*c12*c20 + c02*c10*c21 - c02*c11*c20
+}
+
+private fun determinant4(matrix: IMatrixGetterFloat): Float {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	return c00*c11*c22*c33 - c00*c11*c23*c32 - c00*c12*c21*c33 + c00*c12*c23*c31 + c00*c13*c21*c32 - c00*c13*c22*c31 - c01*c10*c22*c33 + c01*c10*c23*c32 + c01*c12*c20*c33 - c01*c12*c23*c30 - c01*c13*c20*c32 + c01*c13*c22*c30 + c02*c10*c21*c33 - c02*c10*c23*c31 - c02*c11*c20*c33 + c02*c11*c23*c30 + c02*c13*c20*c31 - c02*c13*c21*c30 - c03*c10*c21*c32 + c03*c10*c22*c31 + c03*c11*c20*c32 - c03*c11*c22*c30 - c03*c12*c20*c31 + c03*c12*c21*c30
+}
+
+private fun determinant5(matrix: IMatrixGetterFloat): Float {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c40 = matrix[4, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c41 = matrix[4, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c42 = matrix[4, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	val c43 = matrix[4, 3]
+	val c04 = matrix[0, 4]
+	val c14 = matrix[1, 4]
+	val c24 = matrix[2, 4]
+	val c34 = matrix[3, 4]
+	val c44 = matrix[4, 4]
+	return c00*c11*c22*c33*c44 - c00*c11*c22*c34*c43 - c00*c11*c23*c32*c44 + c00*c11*c23*c34*c42 + c00*c11*c24*c32*c43 - c00*c11*c24*c33*c42 - c00*c12*c21*c33*c44 + c00*c12*c21*c34*c43 + c00*c12*c23*c31*c44 - c00*c12*c23*c34*c41 - c00*c12*c24*c31*c43 + c00*c12*c24*c33*c41 + c00*c13*c21*c32*c44 - c00*c13*c21*c34*c42 - c00*c13*c22*c31*c44 + c00*c13*c22*c34*c41 + c00*c13*c24*c31*c42 - c00*c13*c24*c32*c41 - c00*c14*c21*c32*c43 + c00*c14*c21*c33*c42 + c00*c14*c22*c31*c43 - c00*c14*c22*c33*c41 - c00*c14*c23*c31*c42 + c00*c14*c23*c32*c41 - c01*c10*c22*c33*c44 + c01*c10*c22*c34*c43 + c01*c10*c23*c32*c44 - c01*c10*c23*c34*c42 - c01*c10*c24*c32*c43 + c01*c10*c24*c33*c42 + c01*c12*c20*c33*c44 - c01*c12*c20*c34*c43 - c01*c12*c23*c30*c44 + c01*c12*c23*c34*c40 + c01*c12*c24*c30*c43 - c01*c12*c24*c33*c40 - c01*c13*c20*c32*c44 + c01*c13*c20*c34*c42 + c01*c13*c22*c30*c44 - c01*c13*c22*c34*c40 - c01*c13*c24*c30*c42 + c01*c13*c24*c32*c40 + c01*c14*c20*c32*c43 - c01*c14*c20*c33*c42 - c01*c14*c22*c30*c43 + c01*c14*c22*c33*c40 + c01*c14*c23*c30*c42 - c01*c14*c23*c32*c40 + c02*c10*c21*c33*c44 - c02*c10*c21*c34*c43 - c02*c10*c23*c31*c44 + c02*c10*c23*c34*c41 + c02*c10*c24*c31*c43 - c02*c10*c24*c33*c41 - c02*c11*c20*c33*c44 + c02*c11*c20*c34*c43 + c02*c11*c23*c30*c44 - c02*c11*c23*c34*c40 - c02*c11*c24*c30*c43 + c02*c11*c24*c33*c40 + c02*c13*c20*c31*c44 - c02*c13*c20*c34*c41 - c02*c13*c21*c30*c44 + c02*c13*c21*c34*c40 + c02*c13*c24*c30*c41 - c02*c13*c24*c31*c40 - c02*c14*c20*c31*c43 + c02*c14*c20*c33*c41 + c02*c14*c21*c30*c43 - c02*c14*c21*c33*c40 - c02*c14*c23*c30*c41 + c02*c14*c23*c31*c40 - c03*c10*c21*c32*c44 + c03*c10*c21*c34*c42 + c03*c10*c22*c31*c44 - c03*c10*c22*c34*c41 - c03*c10*c24*c31*c42 + c03*c10*c24*c32*c41 + c03*c11*c20*c32*c44 - c03*c11*c20*c34*c42 - c03*c11*c22*c30*c44 + c03*c11*c22*c34*c40 + c03*c11*c24*c30*c42 - c03*c11*c24*c32*c40 - c03*c12*c20*c31*c44 + c03*c12*c20*c34*c41 + c03*c12*c21*c30*c44 - c03*c12*c21*c34*c40 - c03*c12*c24*c30*c41 + c03*c12*c24*c31*c40 + c03*c14*c20*c31*c42 - c03*c14*c20*c32*c41 - c03*c14*c21*c30*c42 + c03*c14*c21*c32*c40 + c03*c14*c22*c30*c41 - c03*c14*c22*c31*c40 + c04*c10*c21*c32*c43 - c04*c10*c21*c33*c42 - c04*c10*c22*c31*c43 + c04*c10*c22*c33*c41 + c04*c10*c23*c31*c42 - c04*c10*c23*c32*c41 - c04*c11*c20*c32*c43 + c04*c11*c20*c33*c42 + c04*c11*c22*c30*c43 - c04*c11*c22*c33*c40 - c04*c11*c23*c30*c42 + c04*c11*c23*c32*c40 + c04*c12*c20*c31*c43 - c04*c12*c20*c33*c41 - c04*c12*c21*c30*c43 + c04*c12*c21*c33*c40 + c04*c12*c23*c30*c41 - c04*c12*c23*c31*c40 - c04*c13*c20*c31*c42 + c04*c13*c20*c32*c41 + c04*c13*c21*c30*c42 - c04*c13*c21*c32*c40 - c04*c13*c22*c30*c41 + c04*c13*c22*c31*c40
+}
+
+/**
+ * Automatically generated concrete matrix determinant finder. If no mapping exist, this function returns null
+ */
+fun matrixConcreteDeterminant(matrix: IMatrixGetterFloat): Float? {
+	require(matrix.columns == matrix.rows) { "Provided matrix (${matrix.columns}x${matrix.rows}) is not a square matrix" }
+	return when (matrix.columns) {
+		2 -> determinant2(matrix)
+		3 -> determinant3(matrix)
+		4 -> determinant4(matrix)
+		5 -> determinant5(matrix)
+		else -> null
+	}
+}
+

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/generated/DeterminantsInt.kt

@@ -0,0 +1,94 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.matrix.generated
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.narray.*
+
+// Some metaprogramming
+
+private fun determinant2(matrix: IMatrixGetterInt): Int {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	return c00*c11 - c01*c10
+}
+
+private fun determinant3(matrix: IMatrixGetterInt): Int {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	return c00*c11*c22 - c00*c12*c21 - c01*c10*c22 + c01*c12*c20 + c02*c10*c21 - c02*c11*c20
+}
+
+private fun determinant4(matrix: IMatrixGetterInt): Int {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	return c00*c11*c22*c33 - c00*c11*c23*c32 - c00*c12*c21*c33 + c00*c12*c23*c31 + c00*c13*c21*c32 - c00*c13*c22*c31 - c01*c10*c22*c33 + c01*c10*c23*c32 + c01*c12*c20*c33 - c01*c12*c23*c30 - c01*c13*c20*c32 + c01*c13*c22*c30 + c02*c10*c21*c33 - c02*c10*c23*c31 - c02*c11*c20*c33 + c02*c11*c23*c30 + c02*c13*c20*c31 - c02*c13*c21*c30 - c03*c10*c21*c32 + c03*c10*c22*c31 + c03*c11*c20*c32 - c03*c11*c22*c30 - c03*c12*c20*c31 + c03*c12*c21*c30
+}
+
+private fun determinant5(matrix: IMatrixGetterInt): Int {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c40 = matrix[4, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c41 = matrix[4, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c42 = matrix[4, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	val c43 = matrix[4, 3]
+	val c04 = matrix[0, 4]
+	val c14 = matrix[1, 4]
+	val c24 = matrix[2, 4]
+	val c34 = matrix[3, 4]
+	val c44 = matrix[4, 4]
+	return c00*c11*c22*c33*c44 - c00*c11*c22*c34*c43 - c00*c11*c23*c32*c44 + c00*c11*c23*c34*c42 + c00*c11*c24*c32*c43 - c00*c11*c24*c33*c42 - c00*c12*c21*c33*c44 + c00*c12*c21*c34*c43 + c00*c12*c23*c31*c44 - c00*c12*c23*c34*c41 - c00*c12*c24*c31*c43 + c00*c12*c24*c33*c41 + c00*c13*c21*c32*c44 - c00*c13*c21*c34*c42 - c00*c13*c22*c31*c44 + c00*c13*c22*c34*c41 + c00*c13*c24*c31*c42 - c00*c13*c24*c32*c41 - c00*c14*c21*c32*c43 + c00*c14*c21*c33*c42 + c00*c14*c22*c31*c43 - c00*c14*c22*c33*c41 - c00*c14*c23*c31*c42 + c00*c14*c23*c32*c41 - c01*c10*c22*c33*c44 + c01*c10*c22*c34*c43 + c01*c10*c23*c32*c44 - c01*c10*c23*c34*c42 - c01*c10*c24*c32*c43 + c01*c10*c24*c33*c42 + c01*c12*c20*c33*c44 - c01*c12*c20*c34*c43 - c01*c12*c23*c30*c44 + c01*c12*c23*c34*c40 + c01*c12*c24*c30*c43 - c01*c12*c24*c33*c40 - c01*c13*c20*c32*c44 + c01*c13*c20*c34*c42 + c01*c13*c22*c30*c44 - c01*c13*c22*c34*c40 - c01*c13*c24*c30*c42 + c01*c13*c24*c32*c40 + c01*c14*c20*c32*c43 - c01*c14*c20*c33*c42 - c01*c14*c22*c30*c43 + c01*c14*c22*c33*c40 + c01*c14*c23*c30*c42 - c01*c14*c23*c32*c40 + c02*c10*c21*c33*c44 - c02*c10*c21*c34*c43 - c02*c10*c23*c31*c44 + c02*c10*c23*c34*c41 + c02*c10*c24*c31*c43 - c02*c10*c24*c33*c41 - c02*c11*c20*c33*c44 + c02*c11*c20*c34*c43 + c02*c11*c23*c30*c44 - c02*c11*c23*c34*c40 - c02*c11*c24*c30*c43 + c02*c11*c24*c33*c40 + c02*c13*c20*c31*c44 - c02*c13*c20*c34*c41 - c02*c13*c21*c30*c44 + c02*c13*c21*c34*c40 + c02*c13*c24*c30*c41 - c02*c13*c24*c31*c40 - c02*c14*c20*c31*c43 + c02*c14*c20*c33*c41 + c02*c14*c21*c30*c43 - c02*c14*c21*c33*c40 - c02*c14*c23*c30*c41 + c02*c14*c23*c31*c40 - c03*c10*c21*c32*c44 + c03*c10*c21*c34*c42 + c03*c10*c22*c31*c44 - c03*c10*c22*c34*c41 - c03*c10*c24*c31*c42 + c03*c10*c24*c32*c41 + c03*c11*c20*c32*c44 - c03*c11*c20*c34*c42 - c03*c11*c22*c30*c44 + c03*c11*c22*c34*c40 + c03*c11*c24*c30*c42 - c03*c11*c24*c32*c40 - c03*c12*c20*c31*c44 + c03*c12*c20*c34*c41 + c03*c12*c21*c30*c44 - c03*c12*c21*c34*c40 - c03*c12*c24*c30*c41 + c03*c12*c24*c31*c40 + c03*c14*c20*c31*c42 - c03*c14*c20*c32*c41 - c03*c14*c21*c30*c42 + c03*c14*c21*c32*c40 + c03*c14*c22*c30*c41 - c03*c14*c22*c31*c40 + c04*c10*c21*c32*c43 - c04*c10*c21*c33*c42 - c04*c10*c22*c31*c43 + c04*c10*c22*c33*c41 + c04*c10*c23*c31*c42 - c04*c10*c23*c32*c41 - c04*c11*c20*c32*c43 + c04*c11*c20*c33*c42 + c04*c11*c22*c30*c43 - c04*c11*c22*c33*c40 - c04*c11*c23*c30*c42 + c04*c11*c23*c32*c40 + c04*c12*c20*c31*c43 - c04*c12*c20*c33*c41 - c04*c12*c21*c30*c43 + c04*c12*c21*c33*c40 + c04*c12*c23*c30*c41 - c04*c12*c23*c31*c40 - c04*c13*c20*c31*c42 + c04*c13*c20*c32*c41 + c04*c13*c21*c30*c42 - c04*c13*c21*c32*c40 - c04*c13*c22*c30*c41 + c04*c13*c22*c31*c40
+}
+
+/**
+ * Automatically generated concrete matrix determinant finder. If no mapping exist, this function returns null
+ */
+fun matrixConcreteDeterminant(matrix: IMatrixGetterInt): Int? {
+	require(matrix.columns == matrix.rows) { "Provided matrix (${matrix.columns}x${matrix.rows}) is not a square matrix" }
+	return when (matrix.columns) {
+		2 -> determinant2(matrix)
+		3 -> determinant3(matrix)
+		4 -> determinant4(matrix)
+		5 -> determinant5(matrix)
+		else -> null
+	}
+}
+

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/generated/DeterminantsLong.kt

@@ -0,0 +1,94 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.matrix.generated
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.narray.*
+
+// Some metaprogramming
+
+private fun determinant2(matrix: IMatrixGetterLong): Long {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	return c00*c11 - c01*c10
+}
+
+private fun determinant3(matrix: IMatrixGetterLong): Long {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	return c00*c11*c22 - c00*c12*c21 - c01*c10*c22 + c01*c12*c20 + c02*c10*c21 - c02*c11*c20
+}
+
+private fun determinant4(matrix: IMatrixGetterLong): Long {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	return c00*c11*c22*c33 - c00*c11*c23*c32 - c00*c12*c21*c33 + c00*c12*c23*c31 + c00*c13*c21*c32 - c00*c13*c22*c31 - c01*c10*c22*c33 + c01*c10*c23*c32 + c01*c12*c20*c33 - c01*c12*c23*c30 - c01*c13*c20*c32 + c01*c13*c22*c30 + c02*c10*c21*c33 - c02*c10*c23*c31 - c02*c11*c20*c33 + c02*c11*c23*c30 + c02*c13*c20*c31 - c02*c13*c21*c30 - c03*c10*c21*c32 + c03*c10*c22*c31 + c03*c11*c20*c32 - c03*c11*c22*c30 - c03*c12*c20*c31 + c03*c12*c21*c30
+}
+
+private fun determinant5(matrix: IMatrixGetterLong): Long {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c40 = matrix[4, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c41 = matrix[4, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c42 = matrix[4, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	val c43 = matrix[4, 3]
+	val c04 = matrix[0, 4]
+	val c14 = matrix[1, 4]
+	val c24 = matrix[2, 4]
+	val c34 = matrix[3, 4]
+	val c44 = matrix[4, 4]
+	return c00*c11*c22*c33*c44 - c00*c11*c22*c34*c43 - c00*c11*c23*c32*c44 + c00*c11*c23*c34*c42 + c00*c11*c24*c32*c43 - c00*c11*c24*c33*c42 - c00*c12*c21*c33*c44 + c00*c12*c21*c34*c43 + c00*c12*c23*c31*c44 - c00*c12*c23*c34*c41 - c00*c12*c24*c31*c43 + c00*c12*c24*c33*c41 + c00*c13*c21*c32*c44 - c00*c13*c21*c34*c42 - c00*c13*c22*c31*c44 + c00*c13*c22*c34*c41 + c00*c13*c24*c31*c42 - c00*c13*c24*c32*c41 - c00*c14*c21*c32*c43 + c00*c14*c21*c33*c42 + c00*c14*c22*c31*c43 - c00*c14*c22*c33*c41 - c00*c14*c23*c31*c42 + c00*c14*c23*c32*c41 - c01*c10*c22*c33*c44 + c01*c10*c22*c34*c43 + c01*c10*c23*c32*c44 - c01*c10*c23*c34*c42 - c01*c10*c24*c32*c43 + c01*c10*c24*c33*c42 + c01*c12*c20*c33*c44 - c01*c12*c20*c34*c43 - c01*c12*c23*c30*c44 + c01*c12*c23*c34*c40 + c01*c12*c24*c30*c43 - c01*c12*c24*c33*c40 - c01*c13*c20*c32*c44 + c01*c13*c20*c34*c42 + c01*c13*c22*c30*c44 - c01*c13*c22*c34*c40 - c01*c13*c24*c30*c42 + c01*c13*c24*c32*c40 + c01*c14*c20*c32*c43 - c01*c14*c20*c33*c42 - c01*c14*c22*c30*c43 + c01*c14*c22*c33*c40 + c01*c14*c23*c30*c42 - c01*c14*c23*c32*c40 + c02*c10*c21*c33*c44 - c02*c10*c21*c34*c43 - c02*c10*c23*c31*c44 + c02*c10*c23*c34*c41 + c02*c10*c24*c31*c43 - c02*c10*c24*c33*c41 - c02*c11*c20*c33*c44 + c02*c11*c20*c34*c43 + c02*c11*c23*c30*c44 - c02*c11*c23*c34*c40 - c02*c11*c24*c30*c43 + c02*c11*c24*c33*c40 + c02*c13*c20*c31*c44 - c02*c13*c20*c34*c41 - c02*c13*c21*c30*c44 + c02*c13*c21*c34*c40 + c02*c13*c24*c30*c41 - c02*c13*c24*c31*c40 - c02*c14*c20*c31*c43 + c02*c14*c20*c33*c41 + c02*c14*c21*c30*c43 - c02*c14*c21*c33*c40 - c02*c14*c23*c30*c41 + c02*c14*c23*c31*c40 - c03*c10*c21*c32*c44 + c03*c10*c21*c34*c42 + c03*c10*c22*c31*c44 - c03*c10*c22*c34*c41 - c03*c10*c24*c31*c42 + c03*c10*c24*c32*c41 + c03*c11*c20*c32*c44 - c03*c11*c20*c34*c42 - c03*c11*c22*c30*c44 + c03*c11*c22*c34*c40 + c03*c11*c24*c30*c42 - c03*c11*c24*c32*c40 - c03*c12*c20*c31*c44 + c03*c12*c20*c34*c41 + c03*c12*c21*c30*c44 - c03*c12*c21*c34*c40 - c03*c12*c24*c30*c41 + c03*c12*c24*c31*c40 + c03*c14*c20*c31*c42 - c03*c14*c20*c32*c41 - c03*c14*c21*c30*c42 + c03*c14*c21*c32*c40 + c03*c14*c22*c30*c41 - c03*c14*c22*c31*c40 + c04*c10*c21*c32*c43 - c04*c10*c21*c33*c42 - c04*c10*c22*c31*c43 + c04*c10*c22*c33*c41 + c04*c10*c23*c31*c42 - c04*c10*c23*c32*c41 - c04*c11*c20*c32*c43 + c04*c11*c20*c33*c42 + c04*c11*c22*c30*c43 - c04*c11*c22*c33*c40 - c04*c11*c23*c30*c42 + c04*c11*c23*c32*c40 + c04*c12*c20*c31*c43 - c04*c12*c20*c33*c41 - c04*c12*c21*c30*c43 + c04*c12*c21*c33*c40 + c04*c12*c23*c30*c41 - c04*c12*c23*c31*c40 - c04*c13*c20*c31*c42 + c04*c13*c20*c32*c41 + c04*c13*c21*c30*c42 - c04*c13*c21*c32*c40 - c04*c13*c22*c30*c41 + c04*c13*c22*c31*c40
+}
+
+/**
+ * Automatically generated concrete matrix determinant finder. If no mapping exist, this function returns null
+ */
+fun matrixConcreteDeterminant(matrix: IMatrixGetterLong): Long? {
+	require(matrix.columns == matrix.rows) { "Provided matrix (${matrix.columns}x${matrix.rows}) is not a square matrix" }
+	return when (matrix.columns) {
+		2 -> determinant2(matrix)
+		3 -> determinant3(matrix)
+		4 -> determinant4(matrix)
+		5 -> determinant5(matrix)
+		else -> null
+	}
+}
+

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/generated/DeterminantsShort.kt

@@ -0,0 +1,94 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.matrix.generated
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.narray.*
+
+// Some metaprogramming
+
+private fun determinant2(matrix: IMatrixGetterShort): Short {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	return (c00*c11 - c01*c10).toShort()
+}
+
+private fun determinant3(matrix: IMatrixGetterShort): Short {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	return (c00*c11*c22 - c00*c12*c21 - c01*c10*c22 + c01*c12*c20 + c02*c10*c21 - c02*c11*c20).toShort()
+}
+
+private fun determinant4(matrix: IMatrixGetterShort): Short {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	return (c00*c11*c22*c33 - c00*c11*c23*c32 - c00*c12*c21*c33 + c00*c12*c23*c31 + c00*c13*c21*c32 - c00*c13*c22*c31 - c01*c10*c22*c33 + c01*c10*c23*c32 + c01*c12*c20*c33 - c01*c12*c23*c30 - c01*c13*c20*c32 + c01*c13*c22*c30 + c02*c10*c21*c33 - c02*c10*c23*c31 - c02*c11*c20*c33 + c02*c11*c23*c30 + c02*c13*c20*c31 - c02*c13*c21*c30 - c03*c10*c21*c32 + c03*c10*c22*c31 + c03*c11*c20*c32 - c03*c11*c22*c30 - c03*c12*c20*c31 + c03*c12*c21*c30).toShort()
+}
+
+private fun determinant5(matrix: IMatrixGetterShort): Short {
+	val c00 = matrix[0, 0]
+	val c10 = matrix[1, 0]
+	val c20 = matrix[2, 0]
+	val c30 = matrix[3, 0]
+	val c40 = matrix[4, 0]
+	val c01 = matrix[0, 1]
+	val c11 = matrix[1, 1]
+	val c21 = matrix[2, 1]
+	val c31 = matrix[3, 1]
+	val c41 = matrix[4, 1]
+	val c02 = matrix[0, 2]
+	val c12 = matrix[1, 2]
+	val c22 = matrix[2, 2]
+	val c32 = matrix[3, 2]
+	val c42 = matrix[4, 2]
+	val c03 = matrix[0, 3]
+	val c13 = matrix[1, 3]
+	val c23 = matrix[2, 3]
+	val c33 = matrix[3, 3]
+	val c43 = matrix[4, 3]
+	val c04 = matrix[0, 4]
+	val c14 = matrix[1, 4]
+	val c24 = matrix[2, 4]
+	val c34 = matrix[3, 4]
+	val c44 = matrix[4, 4]
+	return (c00*c11*c22*c33*c44 - c00*c11*c22*c34*c43 - c00*c11*c23*c32*c44 + c00*c11*c23*c34*c42 + c00*c11*c24*c32*c43 - c00*c11*c24*c33*c42 - c00*c12*c21*c33*c44 + c00*c12*c21*c34*c43 + c00*c12*c23*c31*c44 - c00*c12*c23*c34*c41 - c00*c12*c24*c31*c43 + c00*c12*c24*c33*c41 + c00*c13*c21*c32*c44 - c00*c13*c21*c34*c42 - c00*c13*c22*c31*c44 + c00*c13*c22*c34*c41 + c00*c13*c24*c31*c42 - c00*c13*c24*c32*c41 - c00*c14*c21*c32*c43 + c00*c14*c21*c33*c42 + c00*c14*c22*c31*c43 - c00*c14*c22*c33*c41 - c00*c14*c23*c31*c42 + c00*c14*c23*c32*c41 - c01*c10*c22*c33*c44 + c01*c10*c22*c34*c43 + c01*c10*c23*c32*c44 - c01*c10*c23*c34*c42 - c01*c10*c24*c32*c43 + c01*c10*c24*c33*c42 + c01*c12*c20*c33*c44 - c01*c12*c20*c34*c43 - c01*c12*c23*c30*c44 + c01*c12*c23*c34*c40 + c01*c12*c24*c30*c43 - c01*c12*c24*c33*c40 - c01*c13*c20*c32*c44 + c01*c13*c20*c34*c42 + c01*c13*c22*c30*c44 - c01*c13*c22*c34*c40 - c01*c13*c24*c30*c42 + c01*c13*c24*c32*c40 + c01*c14*c20*c32*c43 - c01*c14*c20*c33*c42 - c01*c14*c22*c30*c43 + c01*c14*c22*c33*c40 + c01*c14*c23*c30*c42 - c01*c14*c23*c32*c40 + c02*c10*c21*c33*c44 - c02*c10*c21*c34*c43 - c02*c10*c23*c31*c44 + c02*c10*c23*c34*c41 + c02*c10*c24*c31*c43 - c02*c10*c24*c33*c41 - c02*c11*c20*c33*c44 + c02*c11*c20*c34*c43 + c02*c11*c23*c30*c44 - c02*c11*c23*c34*c40 - c02*c11*c24*c30*c43 + c02*c11*c24*c33*c40 + c02*c13*c20*c31*c44 - c02*c13*c20*c34*c41 - c02*c13*c21*c30*c44 + c02*c13*c21*c34*c40 + c02*c13*c24*c30*c41 - c02*c13*c24*c31*c40 - c02*c14*c20*c31*c43 + c02*c14*c20*c33*c41 + c02*c14*c21*c30*c43 - c02*c14*c21*c33*c40 - c02*c14*c23*c30*c41 + c02*c14*c23*c31*c40 - c03*c10*c21*c32*c44 + c03*c10*c21*c34*c42 + c03*c10*c22*c31*c44 - c03*c10*c22*c34*c41 - c03*c10*c24*c31*c42 + c03*c10*c24*c32*c41 + c03*c11*c20*c32*c44 - c03*c11*c20*c34*c42 - c03*c11*c22*c30*c44 + c03*c11*c22*c34*c40 + c03*c11*c24*c30*c42 - c03*c11*c24*c32*c40 - c03*c12*c20*c31*c44 + c03*c12*c20*c34*c41 + c03*c12*c21*c30*c44 - c03*c12*c21*c34*c40 - c03*c12*c24*c30*c41 + c03*c12*c24*c31*c40 + c03*c14*c20*c31*c42 - c03*c14*c20*c32*c41 - c03*c14*c21*c30*c42 + c03*c14*c21*c32*c40 + c03*c14*c22*c30*c41 - c03*c14*c22*c31*c40 + c04*c10*c21*c32*c43 - c04*c10*c21*c33*c42 - c04*c10*c22*c31*c43 + c04*c10*c22*c33*c41 + c04*c10*c23*c31*c42 - c04*c10*c23*c32*c41 - c04*c11*c20*c32*c43 + c04*c11*c20*c33*c42 + c04*c11*c22*c30*c43 - c04*c11*c22*c33*c40 - c04*c11*c23*c30*c42 + c04*c11*c23*c32*c40 + c04*c12*c20*c31*c43 - c04*c12*c20*c33*c41 - c04*c12*c21*c30*c43 + c04*c12*c21*c33*c40 + c04*c12*c23*c30*c41 - c04*c12*c23*c31*c40 - c04*c13*c20*c31*c42 + c04*c13*c20*c32*c41 + c04*c13*c21*c30*c42 - c04*c13*c21*c32*c40 - c04*c13*c22*c30*c41 + c04*c13*c22*c31*c40).toShort()
+}
+
+/**
+ * Automatically generated concrete matrix determinant finder. If no mapping exist, this function returns null
+ */
+fun matrixConcreteDeterminant(matrix: IMatrixGetterShort): Short? {
+	require(matrix.columns == matrix.rows) { "Provided matrix (${matrix.columns}x${matrix.rows}) is not a square matrix" }
+	return when (matrix.columns) {
+		2 -> determinant2(matrix)
+		3 -> determinant3(matrix)
+		4 -> determinant4(matrix)
+		5 -> determinant5(matrix)
+		else -> null
+	}
+}
+

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/ndouble/Matrix2d.kt

@@ -0,0 +1,228 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.matrix.ndouble
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.api.concrete.IMatrix2d
+import ru.dbotthepony.kvector.narray.Double2Dimensional
+import ru.dbotthepony.kvector.vector.ndouble.MutableVector2d
+import ru.dbotthepony.kvector.vector.ndouble.Vector2d
+
+/**
+ * Represents immutable concrete matrix with 2x2 dimensions, storing values as [Double]s.
+ *
+ * See [Matrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [Vector2d], generic interface is represented by [IMatrix2d].
+ *
+ * It does *not* implement [ISquareMatrix] since it doesn't make much sense.
+ */
+class Matrix2d : AbstractMatrixVd<Matrix2d>, IMatrix2d<Matrix2d> {
+	constructor(
+		c00: Double = 1.0, c01: Double = 0.0,
+		c10: Double = 0.0, c11: Double = 1.0,
+	) : super(2, 2, Double2Dimensional(2, 2).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+	})
+
+	private constructor(memory: Double2Dimensional) : super(2, 2, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Double2Dimensional): Matrix2d {
+		requireSizeEquals(memory)
+		return Matrix2d(memory)
+	}
+
+	override val c00: Double get() = memory[0, 0]
+	override val c10: Double get() = memory[1, 0]
+	override val c01: Double get() = memory[0, 1]
+	override val c11: Double get() = memory[1, 1]
+
+	override val r00 by this::c00
+	override val r01 by this::c10
+	override val r10 by this::c01
+	override val r11 by this::c11
+
+	override val a11 by this::c00
+	override val a21 by this::c01
+	override val a12 by this::c10
+	override val a22 by this::c11
+
+	override val b11 by this::c00
+	override val b21 by this::c10
+	override val b12 by this::c01
+	override val b22 by this::c11
+
+	override val c0: Vector2d get() = Vector2d(c00, c01)
+	override val c1: Vector2d get() = Vector2d(c10, c11)
+
+	override val r0: Vector2d get() = Vector2d(r00, r01)
+	override val r1: Vector2d get() = Vector2d(r10, r11)
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Double = 1.0, r01: Double = 0.0,
+			r10: Double = 0.0, r11: Double = 1.0,
+		): Matrix2d {
+			return Matrix2d(
+				c00 = r00, c10 = r01,
+				c01 = r10, c11 = r11,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 *
+		 * Since [Matrix2d] is immutable, it is encouraged you use [ZERO] property instead.
+		 */
+		fun zero(): Matrix2d {
+			return Matrix2d(
+				c00 = 0.0, c10 = 0.0,
+				c01 = 0.0, c11 = 0.0,
+			)
+		}
+
+		/**
+		 * All values of this matrix are zero
+		 */
+		@JvmField val ZERO = zero()
+
+		/**
+		 * Main diagonal of this matrix is 1s
+		 */
+		@JvmField val IDENTITY = Matrix2d()
+	}
+}
+
+/**
+ * Represents mutable concrete matrix with 2x2 dimensions, storing values as [Double]s.
+ *
+ * See [MutableMatrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [MutableVector2d], generic interface is represented by [IMatrix2d].
+ *
+ * It does *not* implement [ISquareMatrix] since it doesn't make much sense.
+ */
+class MutableMatrix2d : AbstractMutableMatrixVd<MutableMatrix2d>, IMatrix2d<MutableMatrix2d> {
+	constructor(
+		c00: Double = 1.0, c01: Double = 0.0,
+		c10: Double = 0.0, c11: Double = 1.0,
+	) : super(2, 2, Double2Dimensional(2, 2).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+	})
+
+	private constructor(memory: Double2Dimensional) : super(2, 2, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Double2Dimensional): MutableMatrix2d {
+		requireSizeEquals(memory)
+		return MutableMatrix2d(memory)
+	}
+
+	override var c00: Double
+		get() = memory[0, 0]
+		set(value) { memory[0, 0] = value }
+	override var c10: Double
+		get() = memory[1, 0]
+		set(value) { memory[1, 0] = value }
+	override var c01: Double
+		get() = memory[0, 1]
+		set(value) { memory[0, 1] = value }
+	override var c11: Double
+		get() = memory[1, 1]
+		set(value) { memory[1, 1] = value }
+
+	override var r00 by this::c00
+	override var r01 by this::c10
+	override var r10 by this::c01
+	override var r11 by this::c11
+
+	override var a11 by this::c00
+	override var a21 by this::c01
+	override var a12 by this::c10
+	override var a22 by this::c11
+
+	override var b11 by this::c00
+	override var b21 by this::c10
+	override var b12 by this::c01
+	override var b22 by this::c11
+
+	override var c0: Vector2d
+		get() = object : MutableVector2d(c00, c01) {
+			override var x by this@MutableMatrix2d::c00
+			override var y by this@MutableMatrix2d::c01
+		}
+		set(value) {
+			c00 = value.x
+			c01 = value.y
+		}
+	override var c1: Vector2d
+		get() = object : MutableVector2d(c10, c11) {
+			override var x by this@MutableMatrix2d::c10
+			override var y by this@MutableMatrix2d::c11
+		}
+		set(value) {
+			c10 = value.x
+			c11 = value.y
+		}
+
+	override var r0: Vector2d
+		get() = object : MutableVector2d(r00, r01) {
+			override var x by this@MutableMatrix2d::r00
+			override var y by this@MutableMatrix2d::r01
+		}
+		set(value) {
+			r00 = value.x
+			r01 = value.y
+		}
+	override var r1: Vector2d
+		get() = object : MutableVector2d(r10, r11) {
+			override var x by this@MutableMatrix2d::r10
+			override var y by this@MutableMatrix2d::r11
+		}
+		set(value) {
+			r10 = value.x
+			r11 = value.y
+		}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Double = 1.0, r01: Double = 0.0,
+			r10: Double = 0.0, r11: Double = 1.0,
+		): MutableMatrix2d {
+			return MutableMatrix2d(
+				c00 = r00, c10 = r01,
+				c01 = r10, c11 = r11,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 */
+		fun zero(): MutableMatrix2d {
+			return MutableMatrix2d(
+				c00 = 0.0, c10 = 0.0,
+				c01 = 0.0, c11 = 0.0,
+			)
+		}
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/ndouble/Matrix3d.kt

@@ -0,0 +1,393 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.matrix.ndouble
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.api.concrete.IMatrix3d
+import ru.dbotthepony.kvector.narray.Double2Dimensional
+import ru.dbotthepony.kvector.vector.ndouble.*
+
+/**
+ * Represents immutable concrete matrix with 3x3 dimensions, storing values as [Double]s.
+ *
+ * See [Matrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [Vector3d], generic interface is represented by [IMatrix3d].
+ */
+class Matrix3d : AbstractMatrixVd<Matrix3d>, IMatrix3d<Matrix3d> {
+	constructor(
+		c00: Double = 1.0, c01: Double = 0.0, c02: Double = 0.0,
+		c10: Double = 0.0, c11: Double = 1.0, c12: Double = 0.0,
+		c20: Double = 0.0, c21: Double = 0.0, c22: Double = 1.0,
+	) : super(3, 3, Double2Dimensional(3, 3).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+		it[2, 0] = c20
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+		it[2, 1] = c21
+
+		it[0, 2] = c02
+		it[1, 2] = c12
+		it[2, 2] = c22
+	})
+
+	private constructor(memory: Double2Dimensional) : super(3, 3, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Double2Dimensional): Matrix3d {
+		requireSizeEquals(memory)
+		return Matrix3d(memory)
+	}
+
+	override val c00: Double get() = memory[0, 0]
+	override val c10: Double get() = memory[1, 0]
+	override val c20: Double get() = memory[2, 0]
+	override val c01: Double get() = memory[0, 1]
+	override val c11: Double get() = memory[1, 1]
+	override val c21: Double get() = memory[2, 1]
+	override val c02: Double get() = memory[0, 2]
+	override val c12: Double get() = memory[1, 2]
+	override val c22: Double get() = memory[2, 2]
+
+	override val r00 by this::c00
+	override val r01 by this::c10
+	override val r02 by this::c20
+	override val r10 by this::c01
+	override val r11 by this::c11
+	override val r12 by this::c21
+	override val r20 by this::c02
+	override val r21 by this::c12
+	override val r22 by this::c22
+
+	override val a11 by this::c00
+	override val a21 by this::c01
+	override val a31 by this::c02
+	override val a12 by this::c10
+	override val a22 by this::c11
+	override val a32 by this::c12
+	override val a13 by this::c20
+	override val a23 by this::c21
+	override val a33 by this::c22
+
+	override val b11 by this::c00
+	override val b21 by this::c10
+	override val b31 by this::c20
+	override val b12 by this::c01
+	override val b22 by this::c11
+	override val b32 by this::c21
+	override val b13 by this::c02
+	override val b23 by this::c12
+	override val b33 by this::c22
+
+	override val c0: Vector3d get() = Vector3d(c00, c01, c02)
+	override val c1: Vector3d get() = Vector3d(c10, c11, c12)
+	override val c2: Vector3d get() = Vector3d(c20, c21, c22)
+
+	override val r0: Vector3d get() = Vector3d(r00, r01, r02)
+	override val r1: Vector3d get() = Vector3d(r10, r11, r12)
+	override val r2: Vector3d get() = Vector3d(r20, r21, r22)
+
+	override fun translate(vector: Vector2d): Matrix3d {
+		return rm(
+			r00, r01, r02 + vector.x,
+			r10, r11, r12 + vector.y,
+			r20, r21, r22,
+		)
+	}
+
+	override fun translateWithMultiplication(vector: Vector2d): Matrix3d {
+		return rm(
+			r00, r01, r02 + vector.x * r00 + vector.y * r01,
+			r10, r11, r12 + vector.x * r10 + vector.y * r11,
+			r20, r21, r22,
+		)
+	}
+
+	override fun scale(vector: Vector2d): Matrix3d {
+		return rm(
+			r00 * vector.x, r01, r02,
+			r10, r11 * vector.y, r12,
+			r20, r21, r22
+		)
+	}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Double = 1.0, r01: Double = 0.0, r02: Double = 0.0,
+			r10: Double = 0.0, r11: Double = 1.0, r12: Double = 0.0,
+			r20: Double = 0.0, r21: Double = 0.0, r22: Double = 1.0,
+		): Matrix3d {
+			return Matrix3d(
+				c00 = r00, c10 = r01, c20 = r02,
+				c01 = r10, c11 = r11, c21 = r12,
+				c02 = r20, c12 = r21, c22 = r22,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 *
+		 * Since [Matrix3d] is immutable, it is encouraged you use [ZERO] property instead.
+		 */
+		fun zero(): Matrix3d {
+			return Matrix3d(
+				c00 = 0.0, c10 = 0.0, c20 = 0.0,
+				c01 = 0.0, c11 = 0.0, c21 = 0.0,
+				c02 = 0.0, c12 = 0.0, c22 = 0.0,
+			)
+		}
+
+		/**
+		 * All values of this matrix are zero
+		 */
+		@JvmField val ZERO = zero()
+
+		/**
+		 * Main diagonal of this matrix is 1s
+		 */
+		@JvmField val IDENTITY = Matrix3d()
+	}
+}
+
+/**
+ * Represents mutable concrete matrix with 3x3 dimensions, storing values as [Double]s.
+ *
+ * See [MutableMatrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [MutableVector3d], generic interface is represented by [IMatrix3d].
+ */
+class MutableMatrix3d : AbstractMutableMatrixVd<MutableMatrix3d>, IMatrix3d<MutableMatrix3d>, IMutableSquareMatrix<MutableMatrix3d, Vector2d> {
+	constructor(
+		c00: Double = 1.0, c01: Double = 0.0, c02: Double = 0.0,
+		c10: Double = 0.0, c11: Double = 1.0, c12: Double = 0.0,
+		c20: Double = 0.0, c21: Double = 0.0, c22: Double = 1.0,
+	) : super(3, 3, Double2Dimensional(3, 3).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+		it[2, 0] = c20
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+		it[2, 1] = c21
+
+		it[0, 2] = c02
+		it[1, 2] = c12
+		it[2, 2] = c22
+	})
+
+	private constructor(memory: Double2Dimensional) : super(3, 3, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Double2Dimensional): MutableMatrix3d {
+		requireSizeEquals(memory)
+		return MutableMatrix3d(memory)
+	}
+
+	override fun translateWithMultiplicationMut(vector: Vector2d): MutableMatrix3d {
+		r02 += vector.x * r00 + vector.y * r01
+		r12 += vector.x * r10 + vector.y * r11
+		return this
+	}
+
+	override fun scaleMut(vector: Vector2d): MutableMatrix3d {
+		r00 *= vector.x
+		r11 *= vector.y
+		return this
+	}
+
+	override var c00: Double
+		get() = memory[0, 0]
+		set(value) { memory[0, 0] = value }
+	override var c10: Double
+		get() = memory[1, 0]
+		set(value) { memory[1, 0] = value }
+	override var c20: Double
+		get() = memory[2, 0]
+		set(value) { memory[2, 0] = value }
+	override var c01: Double
+		get() = memory[0, 1]
+		set(value) { memory[0, 1] = value }
+	override var c11: Double
+		get() = memory[1, 1]
+		set(value) { memory[1, 1] = value }
+	override var c21: Double
+		get() = memory[2, 1]
+		set(value) { memory[2, 1] = value }
+	override var c02: Double
+		get() = memory[0, 2]
+		set(value) { memory[0, 2] = value }
+	override var c12: Double
+		get() = memory[1, 2]
+		set(value) { memory[1, 2] = value }
+	override var c22: Double
+		get() = memory[2, 2]
+		set(value) { memory[2, 2] = value }
+
+	override var r00 by this::c00
+	override var r01 by this::c10
+	override var r02 by this::c20
+	override var r10 by this::c01
+	override var r11 by this::c11
+	override var r12 by this::c21
+	override var r20 by this::c02
+	override var r21 by this::c12
+	override var r22 by this::c22
+
+	override var a11 by this::c00
+	override var a21 by this::c01
+	override var a31 by this::c02
+	override var a12 by this::c10
+	override var a22 by this::c11
+	override var a32 by this::c12
+	override var a13 by this::c20
+	override var a23 by this::c21
+	override var a33 by this::c22
+
+	override var b11 by this::c00
+	override var b21 by this::c10
+	override var b31 by this::c20
+	override var b12 by this::c01
+	override var b22 by this::c11
+	override var b32 by this::c21
+	override var b13 by this::c02
+	override var b23 by this::c12
+	override var b33 by this::c22
+
+	override var translation: Vector2d
+		get() = super.translation
+		set(value) {
+			r02 = value.x
+			r12 = value.y
+		}
+
+	override var c0: Vector3d
+		get() = object : MutableVector3d(c00, c01, c02) {
+			override var x by this@MutableMatrix3d::c00
+			override var y by this@MutableMatrix3d::c01
+			override var z by this@MutableMatrix3d::c02
+		}
+		set(value) {
+			c00 = value.x
+			c01 = value.y
+			c02 = value.z
+		}
+	override var c1: Vector3d
+		get() = object : MutableVector3d(c10, c11, c12) {
+			override var x by this@MutableMatrix3d::c10
+			override var y by this@MutableMatrix3d::c11
+			override var z by this@MutableMatrix3d::c12
+		}
+		set(value) {
+			c10 = value.x
+			c11 = value.y
+			c12 = value.z
+		}
+	override var c2: Vector3d
+		get() = object : MutableVector3d(c20, c21, c22) {
+			override var x by this@MutableMatrix3d::c20
+			override var y by this@MutableMatrix3d::c21
+			override var z by this@MutableMatrix3d::c22
+		}
+		set(value) {
+			c20 = value.x
+			c21 = value.y
+			c22 = value.z
+		}
+
+	override var r0: Vector3d
+		get() = object : MutableVector3d(r00, r01, r02) {
+			override var x by this@MutableMatrix3d::r00
+			override var y by this@MutableMatrix3d::r01
+			override var z by this@MutableMatrix3d::r02
+		}
+		set(value) {
+			r00 = value.x
+			r01 = value.y
+			r02 = value.z
+		}
+	override var r1: Vector3d
+		get() = object : MutableVector3d(r10, r11, r12) {
+			override var x by this@MutableMatrix3d::r10
+			override var y by this@MutableMatrix3d::r11
+			override var z by this@MutableMatrix3d::r12
+		}
+		set(value) {
+			r10 = value.x
+			r11 = value.y
+			r12 = value.z
+		}
+	override var r2: Vector3d
+		get() = object : MutableVector3d(r20, r21, r22) {
+			override var x by this@MutableMatrix3d::r20
+			override var y by this@MutableMatrix3d::r21
+			override var z by this@MutableMatrix3d::r22
+		}
+		set(value) {
+			r20 = value.x
+			r21 = value.y
+			r22 = value.z
+		}
+
+	override fun translate(vector: Vector2d): MutableMatrix3d {
+		return rm(
+			r00, r01, r02 + vector.x,
+			r10, r11, r12 + vector.y,
+			r20, r21, r22,
+		)
+	}
+
+	override fun translateWithMultiplication(vector: Vector2d): MutableMatrix3d {
+		return rm(
+			r00, r01, r02 + vector.x * r00 + vector.y * r01,
+			r10, r11, r12 + vector.x * r10 + vector.y * r11,
+			r20, r21, r22,
+		)
+	}
+
+	override fun scale(vector: Vector2d): MutableMatrix3d {
+		return rm(
+			r00 * vector.x, r01, r02,
+			r10, r11 * vector.y, r12,
+			r20, r21, r22
+		)
+	}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Double = 1.0, r01: Double = 0.0, r02: Double = 0.0,
+			r10: Double = 0.0, r11: Double = 1.0, r12: Double = 0.0,
+			r20: Double = 0.0, r21: Double = 0.0, r22: Double = 1.0,
+		): MutableMatrix3d {
+			return MutableMatrix3d(
+				c00 = r00, c10 = r01, c20 = r02,
+				c01 = r10, c11 = r11, c21 = r12,
+				c02 = r20, c12 = r21, c22 = r22,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 */
+		fun zero(): MutableMatrix3d {
+			return MutableMatrix3d(
+				c00 = 0.0, c10 = 0.0, c20 = 0.0,
+				c01 = 0.0, c11 = 0.0, c21 = 0.0,
+				c02 = 0.0, c12 = 0.0, c22 = 0.0,
+			)
+		}
+	}
+}
+

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/ndouble/Matrix4d.kt

@@ -0,0 +1,569 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.matrix.ndouble
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.api.concrete.IMatrix4d
+import ru.dbotthepony.kvector.matrix.ndouble.Matrix4d.Companion.ZERO
+import ru.dbotthepony.kvector.matrix.ndouble.Matrix4d.Companion.rm
+import ru.dbotthepony.kvector.matrix.ndouble.MutableMatrix4d.Companion.rm
+import ru.dbotthepony.kvector.narray.Double2Dimensional
+import ru.dbotthepony.kvector.vector.ndouble.MutableVector4d
+import ru.dbotthepony.kvector.vector.ndouble.Vector3d
+import ru.dbotthepony.kvector.vector.ndouble.Vector4d
+
+/**
+ * Represents immutable concrete matrix with 4x4 dimensions, storing values as [Double]s.
+ *
+ * Primary constructor accept values in *Column-Major* order, that is, first row of values
+ * is first column in matrix. For *Row-Major* constructor, you should use [rm]
+ * companion object method.
+ *
+ * By default, primary constructor initialize identity matrix, e.g. main diagonal set to 1s.
+ *
+ * Matrices have multiple sets of properties to access values stored, for convenience of use:
+ * - rXY - access row X and column Y
+ * - cXY - access column X and row Y
+ * - aXY - access row X and column Y, but indices start from 1
+ * - bXY - access column X and row Y, but indices start from 1
+ * - cX  - access column X as [Vector4d]
+ * - rX  - access row X as [Vector4d]
+ *
+ * **If you don't care about mutability of matrix your method want to accept, use [IMatrix4d]**,
+ * because [MutableMatrix4d] is not a subtype of [Matrix4d], but they both are subtype of [IMatrix4d].
+ */
+class Matrix4d : AbstractMatrixVd<Matrix4d>, IMatrix4d<Matrix4d> {
+	constructor(
+		c00: Double = 1.0, c01: Double = 0.0, c02: Double = 0.0, c03: Double = 0.0,
+		c10: Double = 0.0, c11: Double = 1.0, c12: Double = 0.0, c13: Double = 0.0,
+		c20: Double = 0.0, c21: Double = 0.0, c22: Double = 1.0, c23: Double = 0.0,
+		c30: Double = 0.0, c31: Double = 0.0, c32: Double = 0.0, c33: Double = 1.0,
+	) : super(4, 4, Double2Dimensional(4, 4).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+		it[2, 0] = c20
+		it[3, 0] = c30
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+		it[2, 1] = c21
+		it[3, 1] = c31
+
+		it[0, 2] = c02
+		it[1, 2] = c12
+		it[2, 2] = c22
+		it[3, 2] = c32
+
+		it[0, 3] = c03
+		it[1, 3] = c13
+		it[2, 3] = c23
+		it[3, 3] = c33
+	})
+
+	private constructor(memory: Double2Dimensional) : super(4, 4, memory)
+	override val flexible: Boolean = false
+
+	override val c00: Double get() = memory[0, 0]
+	override val c10: Double get() = memory[1, 0]
+	override val c20: Double get() = memory[2, 0]
+	override val c30: Double get() = memory[3, 0]
+	override val c01: Double get() = memory[0, 1]
+	override val c11: Double get() = memory[1, 1]
+	override val c21: Double get() = memory[2, 1]
+	override val c31: Double get() = memory[3, 1]
+	override val c02: Double get() = memory[0, 2]
+	override val c12: Double get() = memory[1, 2]
+	override val c22: Double get() = memory[2, 2]
+	override val c32: Double get() = memory[3, 2]
+	override val c03: Double get() = memory[0, 3]
+	override val c13: Double get() = memory[1, 3]
+	override val c23: Double get() = memory[2, 3]
+	override val c33: Double get() = memory[3, 3]
+
+	override val r00 by this::c00
+	override val r01 by this::c10
+	override val r02 by this::c20
+	override val r03 by this::c30
+	override val r10 by this::c01
+	override val r11 by this::c11
+	override val r12 by this::c21
+	override val r13 by this::c31
+	override val r20 by this::c02
+	override val r21 by this::c12
+	override val r22 by this::c22
+	override val r23 by this::c32
+	override val r30 by this::c03
+	override val r31 by this::c13
+	override val r32 by this::c23
+	override val r33 by this::c33
+
+	override val a11 by this::c00
+	override val a21 by this::c01
+	override val a31 by this::c02
+	override val a41 by this::c03
+	override val a12 by this::c10
+	override val a22 by this::c11
+	override val a32 by this::c12
+	override val a42 by this::c13
+	override val a13 by this::c20
+	override val a23 by this::c21
+	override val a33 by this::c22
+	override val a43 by this::c23
+	override val a14 by this::c30
+	override val a24 by this::c31
+	override val a34 by this::c32
+	override val a44 by this::c33
+
+	override val b11 by this::c00
+	override val b21 by this::c10
+	override val b31 by this::c20
+	override val b41 by this::c30
+	override val b12 by this::c01
+	override val b22 by this::c11
+	override val b32 by this::c21
+	override val b42 by this::c31
+	override val b13 by this::c02
+	override val b23 by this::c12
+	override val b33 by this::c22
+	override val b43 by this::c32
+	override val b14 by this::c03
+	override val b24 by this::c13
+	override val b34 by this::c23
+	override val b44 by this::c33
+
+	override val c0: Vector4d get() = Vector4d(c00, c01, c02, c03)
+	override val c1: Vector4d get() = Vector4d(c10, c11, c12, c13)
+	override val c2: Vector4d get() = Vector4d(c20, c21, c22, c23)
+	override val c3: Vector4d get() = Vector4d(c30, c31, c32, c33)
+
+	override val r0: Vector4d get() = Vector4d(r00, r01, r02, r03)
+	override val r1: Vector4d get() = Vector4d(r10, r11, r12, r13)
+	override val r2: Vector4d get() = Vector4d(r20, r21, r22, r23)
+	override val r3: Vector4d get() = Vector4d(r30, r31, r32, r33)
+
+	override fun factorize(memory: Double2Dimensional): Matrix4d {
+		requireSizeEquals(memory)
+		return Matrix4d(memory)
+	}
+
+	override fun translate(vector: Vector3d): Matrix4d {
+		return rm(
+			r00, r01, r02, r03 + vector.x,
+			r10, r11, r12, r13 + vector.y,
+			r20, r21, r22, r23 + vector.z,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun translateWithMultiplication(vector: Vector3d): Matrix4d {
+		return rm(
+			r00, r01, r02, r03 + vector.x * r00 + vector.y * r01 + vector.z * r02,
+			r10, r11, r12, r13 + vector.x * r10 + vector.y * r11 + vector.z * r12,
+			r20, r21, r22, r23 + vector.x * r20 + vector.y * r21 + vector.z * r22,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun scale(vector: Vector3d): Matrix4d {
+		return rm(
+			r00 * vector.x, r01, r02, r03,
+			r10, r11 * vector.y, r12, r13,
+			r20, r21, r22 * vector.z, r23,
+			r30, r31, r32, r33,
+		)
+	}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Double = 1.0, r01: Double = 0.0, r02: Double = 0.0, r03: Double = 0.0,
+			r10: Double = 0.0, r11: Double = 1.0, r12: Double = 0.0, r13: Double = 0.0,
+			r20: Double = 0.0, r21: Double = 0.0, r22: Double = 1.0, r23: Double = 0.0,
+			r30: Double = 0.0, r31: Double = 0.0, r32: Double = 0.0, r33: Double = 1.0,
+		): Matrix4d {
+			return Matrix4d(
+				c00 = r00, c10 = r01, c20 = r02, c30 = r03,
+				c01 = r10, c11 = r11, c21 = r12, c31 = r13,
+				c02 = r20, c12 = r21, c22 = r22, c32 = r23,
+				c03 = r30, c13 = r31, c23 = r32, c33 = r33,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 *
+		 * Since [Matrix4d] is immutable, it is encouraged you use [ZERO] property instead.
+		 */
+		fun zero(): Matrix4d {
+			return Matrix4d(
+				c00 = 0.0, c10 = 0.0, c20 = 0.0, c30 = 0.0,
+				c01 = 0.0, c11 = 0.0, c21 = 0.0, c31 = 0.0,
+				c02 = 0.0, c12 = 0.0, c22 = 0.0, c32 = 0.0,
+				c03 = 0.0, c13 = 0.0, c23 = 0.0, c33 = 0.0,
+			)
+		}
+
+		/**
+		 * All values of this matrix are zero
+		 */
+		@JvmField val ZERO = zero()
+
+		/**
+		 * Main diagonal of this matrix is 1s
+		 */
+		@JvmField val IDENTITY = Matrix4d()
+	}
+}
+
+/**
+ * Represents mutable concrete matrix with 4x4 dimensions, storing values as [Double]s
+ *
+ * Primary constructor accept values in *Column-Major* order, that is, first row of values
+ * is first column in matrix. For *Row-Major* constructor, you should use [rm]
+ * companion object method.
+ *
+ * Same notes about properties of [Matrix4d] apply.
+ *
+ * **This class is not a subclass of [Matrix4d]**, but a subclass of [IMatrix4d].
+ *
+ * Differences:
+ * - All properties are mutable
+ * - Vectorized access return [MutableVector4d], which actually reflect columns/rows of this matrix.
+ * That is, any changes done to matrix will be instantly reflected by vector, and any changes to vector
+ * will be reflected in matrix.
+ * - Vectorized access has setter, and when writing [Vector4d] to it, it will update associated column/row values
+ *
+ */
+class MutableMatrix4d : AbstractMutableMatrixVd<MutableMatrix4d>, IMatrix4d<MutableMatrix4d>, IMutableSquareMatrix<MutableMatrix4d, Vector3d> {
+	constructor(
+		c00: Double = 1.0, c01: Double = 0.0, c02: Double = 0.0, c03: Double = 0.0,
+		c10: Double = 0.0, c11: Double = 1.0, c12: Double = 0.0, c13: Double = 0.0,
+		c20: Double = 0.0, c21: Double = 0.0, c22: Double = 1.0, c23: Double = 0.0,
+		c30: Double = 0.0, c31: Double = 0.0, c32: Double = 0.0, c33: Double = 1.0,
+	) : super(4, 4, Double2Dimensional(4, 4).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+		it[2, 0] = c20
+		it[3, 0] = c30
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+		it[2, 1] = c21
+		it[3, 1] = c31
+
+		it[0, 2] = c02
+		it[1, 2] = c12
+		it[2, 2] = c22
+		it[3, 2] = c32
+
+		it[0, 3] = c03
+		it[1, 3] = c13
+		it[2, 3] = c23
+		it[3, 3] = c33
+	})
+
+	private constructor(memory: Double2Dimensional) : super(4, 4, memory)
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Double2Dimensional): MutableMatrix4d {
+		requireSizeEquals(memory)
+		return MutableMatrix4d(memory)
+	}
+
+	override fun translate(vector: Vector3d): MutableMatrix4d {
+		return rm(
+			r00, r01, r02, r03 + vector.x,
+			r10, r11, r12, r13 + vector.y,
+			r20, r21, r22, r23 + vector.z,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun translateWithMultiplication(vector: Vector3d): MutableMatrix4d {
+		return rm(
+			r00, r01, r02, r03 + vector.x * r00 + vector.y * r01 + vector.z * r02,
+			r10, r11, r12, r13 + vector.x * r10 + vector.y * r11 + vector.z * r12,
+			r20, r21, r22, r23 + vector.x * r20 + vector.y * r21 + vector.z * r22,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun scale(vector: Vector3d): MutableMatrix4d {
+		return rm(
+			r00 * vector.x, r01, r02, r03,
+			r10, r11 * vector.y, r12, r13,
+			r20, r21, r22 * vector.z, r23,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun translateWithMultiplicationMut(vector: Vector3d): MutableMatrix4d {
+		r03 += vector.x * r00 + vector.y * r01 + vector.z * r02
+		r13 += vector.x * r10 + vector.y * r11 + vector.z * r12
+		r23 += vector.x * r20 + vector.y * r21 + vector.z * r22
+		return this
+	}
+
+	override fun scaleMut(vector: Vector3d): MutableMatrix4d {
+		c00 *= vector.x
+		c11 *= vector.y
+		c22 *= vector.z
+		return this
+	}
+
+	override var translation: Vector3d
+		get() = super.translation
+		set(value) {
+			r03 = value.x
+			r13 = value.y
+			r23 = value.z
+		}
+
+	override var c00: Double
+		get() = memory[0, 0]
+		set(value) { memory[0, 0] = value }
+	override var c10: Double
+		get() = memory[1, 0]
+		set(value) { memory[1, 0] = value }
+	override var c20: Double
+		get() = memory[2, 0]
+		set(value) { memory[2, 0] = value }
+	override var c30: Double
+		get() = memory[3, 0]
+		set(value) { memory[3, 0] = value }
+	override var c01: Double
+		get() = memory[0, 1]
+		set(value) { memory[0, 1] = value }
+	override var c11: Double
+		get() = memory[1, 1]
+		set(value) { memory[1, 1] = value }
+	override var c21: Double
+		get() = memory[2, 1]
+		set(value) { memory[2, 1] = value }
+	override var c31: Double
+		get() = memory[3, 1]
+		set(value) { memory[3, 1] = value }
+	override var c02: Double
+		get() = memory[0, 2]
+		set(value) { memory[0, 2] = value }
+	override var c12: Double
+		get() = memory[1, 2]
+		set(value) { memory[1, 2] = value }
+	override var c22: Double
+		get() = memory[2, 2]
+		set(value) { memory[2, 2] = value }
+	override var c32: Double
+		get() = memory[3, 2]
+		set(value) { memory[3, 2] = value }
+	override var c03: Double
+		get() = memory[0, 3]
+		set(value) { memory[0, 3] = value }
+	override var c13: Double
+		get() = memory[1, 3]
+		set(value) { memory[1, 3] = value }
+	override var c23: Double
+		get() = memory[2, 3]
+		set(value) { memory[2, 3] = value }
+	override var c33: Double
+		get() = memory[3, 3]
+		set(value) { memory[3, 3] = value }
+
+	override var r00 by this::c00
+	override var r01 by this::c10
+	override var r02 by this::c20
+	override var r03 by this::c30
+	override var r10 by this::c01
+	override var r11 by this::c11
+	override var r12 by this::c21
+	override var r13 by this::c31
+	override var r20 by this::c02
+	override var r21 by this::c12
+	override var r22 by this::c22
+	override var r23 by this::c32
+	override var r30 by this::c03
+	override var r31 by this::c13
+	override var r32 by this::c23
+	override var r33 by this::c33
+
+	override var a11 by this::c00
+	override var a21 by this::c01
+	override var a31 by this::c02
+	override var a41 by this::c03
+	override var a12 by this::c10
+	override var a22 by this::c11
+	override var a32 by this::c12
+	override var a42 by this::c13
+	override var a13 by this::c20
+	override var a23 by this::c21
+	override var a33 by this::c22
+	override var a43 by this::c23
+	override var a14 by this::c30
+	override var a24 by this::c31
+	override var a34 by this::c32
+	override var a44 by this::c33
+
+	override var b11 by this::c00
+	override var b21 by this::c01
+	override var b31 by this::c02
+	override var b41 by this::c03
+	override var b12 by this::c10
+	override var b22 by this::c11
+	override var b32 by this::c12
+	override var b42 by this::c13
+	override var b13 by this::c20
+	override var b23 by this::c21
+	override var b33 by this::c22
+	override var b43 by this::c23
+	override var b14 by this::c30
+	override var b24 by this::c31
+	override var b34 by this::c32
+	override var b44 by this::c33
+
+	override var c0: Vector4d
+		get() = object : MutableVector4d(c00, c01, c02, c03) {
+			override var x by this@MutableMatrix4d::c00
+			override var y by this@MutableMatrix4d::c01
+			override var z by this@MutableMatrix4d::c02
+			override var w by this@MutableMatrix4d::c03
+		}
+		set(value) {
+			c00 = value.x
+			c01 = value.y
+			c02 = value.z
+			c03 = value.w
+		}
+
+	override var c1: Vector4d
+		get() = object : MutableVector4d(c10, c11, c12, c13) {
+			override var x by this@MutableMatrix4d::c10
+			override var y by this@MutableMatrix4d::c11
+			override var z by this@MutableMatrix4d::c12
+			override var w by this@MutableMatrix4d::c13
+		}
+		set(value) {
+			c10 = value.x
+			c11 = value.y
+			c12 = value.z
+			c13 = value.w
+		}
+
+	override var c2: Vector4d
+		get() = object : MutableVector4d(c20, c21, c22, c23) {
+			override var x by this@MutableMatrix4d::c20
+			override var y by this@MutableMatrix4d::c21
+			override var z by this@MutableMatrix4d::c22
+			override var w by this@MutableMatrix4d::c23
+		}
+		set(value) {
+			c20 = value.x
+			c21 = value.y
+			c22 = value.z
+			c23 = value.w
+		}
+
+	override var c3: Vector4d
+		get() = object : MutableVector4d(c30, c31, c32, c33) {
+			override var x by this@MutableMatrix4d::c30
+			override var y by this@MutableMatrix4d::c31
+			override var z by this@MutableMatrix4d::c32
+			override var w by this@MutableMatrix4d::c33
+		}
+		set(value) {
+			c30 = value.x
+			c31 = value.y
+			c32 = value.z
+			c33 = value.w
+		}
+
+	override var r0: Vector4d
+		get() = object : MutableVector4d(r00, r01, r02, r03) {
+			override var x by this@MutableMatrix4d::r00
+			override var y by this@MutableMatrix4d::r01
+			override var z by this@MutableMatrix4d::r02
+			override var w by this@MutableMatrix4d::r03
+		}
+		set(value) {
+			r00 = value.x
+			r01 = value.y
+			r02 = value.z
+			r03 = value.w
+		}
+
+	override var r1: Vector4d
+		get() = object : MutableVector4d(r10, r11, r12, r13) {
+			override var x by this@MutableMatrix4d::r10
+			override var y by this@MutableMatrix4d::r11
+			override var z by this@MutableMatrix4d::r12
+			override var w by this@MutableMatrix4d::r13
+		}
+		set(value) {
+			r10 = value.x
+			r11 = value.y
+			r12 = value.z
+			r13 = value.w
+		}
+
+	override var r2: Vector4d
+		get() = object : MutableVector4d(r20, r21, r22, r23) {
+			override var x by this@MutableMatrix4d::r20
+			override var y by this@MutableMatrix4d::r21
+			override var z by this@MutableMatrix4d::r22
+			override var w by this@MutableMatrix4d::r23
+		}
+		set(value) {
+			r20 = value.x
+			r21 = value.y
+			r22 = value.z
+			r23 = value.w
+		}
+
+	override var r3: Vector4d
+		get() = object : MutableVector4d(r30, r31, r32, r33) {
+			override var x by this@MutableMatrix4d::r30
+			override var y by this@MutableMatrix4d::r31
+			override var z by this@MutableMatrix4d::r32
+			override var w by this@MutableMatrix4d::r33
+		}
+		set(value) {
+			r30 = value.x
+			r31 = value.y
+			r32 = value.z
+			r33 = value.w
+		}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Double = 1.0, r01: Double = 0.0, r02: Double = 0.0, r03: Double = 0.0,
+			r10: Double = 0.0, r11: Double = 1.0, r12: Double = 0.0, r13: Double = 0.0,
+			r20: Double = 0.0, r21: Double = 0.0, r22: Double = 1.0, r23: Double = 0.0,
+			r30: Double = 0.0, r31: Double = 0.0, r32: Double = 0.0, r33: Double = 1.0,
+		): MutableMatrix4d {
+			return MutableMatrix4d(
+				c00 = r00, c10 = r01, c20 = r02, c30 = r03,
+				c01 = r10, c11 = r11, c21 = r12, c31 = r13,
+				c02 = r20, c12 = r21, c22 = r22, c32 = r23,
+				c03 = r30, c13 = r31, c23 = r32, c33 = r33,
+			)
+		}
+
+		/**
+		 * Initializes new mutable zero matrix.
+		 */
+		fun zero(): MutableMatrix4d {
+			return MutableMatrix4d(
+				c00 = 0.0, c10 = 0.0, c20 = 0.0, c30 = 0.0,
+				c01 = 0.0, c11 = 0.0, c21 = 0.0, c31 = 0.0,
+				c02 = 0.0, c12 = 0.0, c22 = 0.0, c32 = 0.0,
+				c03 = 0.0, c13 = 0.0, c23 = 0.0, c33 = 0.0,
+			)
+		}
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/ndouble/MatrixVd.kt

@@ -0,0 +1,316 @@
+
+@file:Suppress("unchecked_cast", "unused")
+
+package ru.dbotthepony.kvector.matrix.ndouble
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.matrix.generated.MultiplicationsDouble
+import ru.dbotthepony.kvector.matrix.matrixDeterminant
+import ru.dbotthepony.kvector.matrix.multiplyMatrix
+import ru.dbotthepony.kvector.matrix.transposeMatrix
+import ru.dbotthepony.kvector.narray.Double2Dimensional
+
+private fun checkRows(value: Int): Int {
+	require(value > 0) { "Invalid amount of rows $value" }
+	return value
+}
+
+private fun checkColumns(value: Int): Int {
+	require(value > 0) { "Invalid amount of columns $value" }
+	return value
+}
+
+/**
+ * Abstract class with only one protected abstract method: [factorize].
+ *
+ * This class is meant to be only internally overridden (to implement interfaces), but if you really need to, you can
+ * extend this class.
+ */
+abstract class AbstractMatrixVd<T : AbstractMatrixVd<T>> protected constructor(
+	final override val columns: Int,
+	final override val rows: Int,
+	@JvmField protected val memory: Double2Dimensional
+) : IMatrix<T>, IDoubleMatrix<T>, ITransposable<T> {
+	/**
+	 * To avoid middle-object creation when deriving from [AbstractMatrixVd] ([MatrixVd]), this method
+	 * allows to factory produce new instances of final class
+	 */
+	protected abstract fun factorize(memory: Double2Dimensional): T
+	protected open val flexible = true
+
+	final override fun get(column: Int, row: Int): Double {
+		return memory[column, row]
+	}
+
+	override fun plus(other: IMatrixGetterDouble): T {
+		requireSizeEquals(other)
+
+		val result = Double2Dimensional(columns, rows)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				result[column, row] = memory[column, row] + other[column, row]
+			}
+		}
+
+		return factorize(result)
+	}
+
+	override fun minus(other: IMatrixGetterDouble): T {
+		requireSizeEquals(other)
+
+		val result = Double2Dimensional(columns, rows)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				result[column, row] = memory[column, row] - other[column, row]
+			}
+		}
+
+		return factorize(result)
+	}
+
+	override fun times(other: IMatrixGetterDouble): T {
+		require(flexible || sizeEquals(other)) { "${this::class.qualifiedName} is not a flexible" }
+		val result = multiplyMatrix(this, other)
+		return factorize(result)
+	}
+
+	override fun times(other: Double): T {
+		val result = Double2Dimensional(columns, rows)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				result[column, row] = memory[column, row] * other
+			}
+		}
+
+		return factorize(result)
+	}
+
+	override fun div(other: Double): T {
+		val result = Double2Dimensional(columns, rows)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				result[column, row] = memory[column, row] / other
+			}
+		}
+
+		return factorize(result)
+	}
+
+	override val transposed: T
+		get() {
+			val result = transposeMatrix(this)
+			return factorize(result)
+		}
+
+	override val trace: Double?
+		get() {
+			if (!isSquareMatrix)
+				return null
+
+			var calc = 0.0
+
+			for (i in 0 until rows) {
+				calc += memory[columns, rows]
+			}
+
+			return calc
+		}
+
+	override val determinant: Double?
+		get() {
+			if (!isSquareMatrix)
+				return null
+
+			return matrixDeterminant(this)
+		}
+
+	override val isFinite: Boolean
+		get() {
+			for (column in 0 until columns) {
+				for (row in 0 until rows) {
+					if (!memory[column, row].isFinite()) {
+						return false
+					}
+				}
+			}
+
+			return true
+		}
+
+	override val isNaN: Boolean
+		get() {
+			for (column in 0 until columns) {
+				for (row in 0 until rows) {
+					if (memory[column, row].isNaN()) {
+						return true
+					}
+				}
+			}
+
+			return false
+		}
+}
+
+/**
+ * Abstract class inheriting [AbstractMatrixVd], implementing mutating methods.
+ *
+ * This class is meant to be only internally overridden (to implement interfaces), but if you really need to, you can
+ * extend this class.
+ */
+abstract class AbstractMutableMatrixVd<T : AbstractMutableMatrixVd<T>> protected constructor(
+	columns: Int,
+	rows: Int,
+	memory: Double2Dimensional
+) : AbstractMatrixVd<T>(columns, rows, memory), IMutableDoubleMatrix<T>, IMutableTransposable<T> {
+	final override fun set(column: Int, row: Int, value: Double) {
+		memory[column, row] = value
+	}
+
+	override fun timesMut(other: Double): T {
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] *= other
+			}
+		}
+
+		return this as T
+	}
+
+	override fun divMut(other: Double): T {
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] /= other
+			}
+		}
+
+		return this as T
+	}
+
+	override fun timesMut(other: IMatrixGetterDouble): T {
+		requireSizeEquals(other)
+
+		if (MultiplicationsDouble.multiplyMatrix(this, other, this) == null) {
+			val result = multiplyMatrix(this, other)
+
+			for (column in 0 until columns) {
+				for (row in 0 until rows) {
+					memory[column, row] = result[column, row]
+				}
+			}
+		}
+
+		return this as T
+	}
+
+	override fun plusMut(other: IMatrixGetterDouble): T {
+		requireSizeEquals(other)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] += other[column, row]
+			}
+		}
+
+		return this as T
+	}
+
+	override fun minusMut(other: IMatrixGetterDouble): T {
+		requireSizeEquals(other)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] -= other[column, row]
+			}
+		}
+
+		return this as T
+	}
+
+	override fun transpose(): T {
+		check(isSquareMatrix) { "This matrix is not a square matrix (${columns}x${rows})" }
+
+		val result = transposeMatrix(this)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] = result[column, row]
+			}
+		}
+
+		return this as T
+	}
+}
+
+/**
+ * Represents immutable matrix with arbitrary dimensions, storing values as [Double]s,
+ * backed by [Double2Dimensional].
+ *
+ * Matrix is initialized to zeros upon creation.
+ */
+open class MatrixVd protected constructor(
+	columns: Int,
+	rows: Int,
+	memory: Double2Dimensional
+) : AbstractMatrixVd<MatrixVd>(columns, rows, memory) {
+	constructor(columns: Int, rows: Int) : this(checkColumns(columns), checkRows(rows), Double2Dimensional(checkColumns(columns), checkRows(rows)))
+
+	override fun factorize(memory: Double2Dimensional): MatrixVd {
+		return MatrixVd(memory.columns, memory.rows, memory)
+	}
+
+	companion object {
+		/**
+		 * Copies specified matrix into new [MatrixVd]
+		 */
+		fun copy(input: IMatrixGetterDouble): MatrixVd {
+			val memory = Double2Dimensional(input.columns, input.rows)
+
+			for (column in 0 until input.columns) {
+				for (row in 0 until input.rows) {
+					memory[column, row] = input[column, row]
+				}
+			}
+
+			return MatrixVd(input.columns, input.rows, memory)
+		}
+	}
+}
+
+/**
+ * Represents mutable matrix with arbitrary dimensions, storing values as [Double]s,
+ * backed by [Double2Dimensional].
+ *
+ * Matrix is initialized to zeros upon creation.
+ */
+open class MutableMatrixVd protected constructor(
+	columns: Int,
+	rows: Int,
+	memory: Double2Dimensional
+) : AbstractMutableMatrixVd<MutableMatrixVd>(columns, rows, memory) {
+	constructor(columns: Int, rows: Int) : this(checkColumns(columns), checkRows(rows), Double2Dimensional(checkColumns(columns), checkRows(rows)))
+
+	override fun factorize(memory: Double2Dimensional): MutableMatrixVd {
+		return MutableMatrixVd(memory.columns, memory.rows, memory)
+	}
+
+	companion object {
+		/**
+		 * Copies specified matrix into new [MutableMatrixVd]
+		 */
+		fun copy(input: IMatrixGetterDouble): MutableMatrixVd {
+			val memory = Double2Dimensional(input.columns, input.rows)
+
+			for (column in 0 until input.columns) {
+				for (row in 0 until input.rows) {
+					memory[column, row] = input[column, row]
+				}
+			}
+
+			return MutableMatrixVd(input.columns, input.rows, memory)
+		}
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/nfloat/Matrix2f.kt

@@ -0,0 +1,226 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.matrix.nfloat
+
+import ru.dbotthepony.kvector.api.concrete.IMatrix2f
+import ru.dbotthepony.kvector.narray.Float2Dimensional
+import ru.dbotthepony.kvector.vector.nfloat.Vector2f
+import ru.dbotthepony.kvector.matrix.ndouble.Matrix4d
+import ru.dbotthepony.kvector.matrix.ndouble.MutableMatrix4d
+import ru.dbotthepony.kvector.vector.nfloat.MutableVector2f
+
+/**
+ * Represents immutable concrete matrix with 2x2 dimensions, storing values as [Float]s.
+ *
+ * See [Matrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [Vector2f], generic interface is represented by [IMatrix2f].
+ */
+class Matrix2f : AbstractMatrixVf<Matrix2f>, IMatrix2f<Matrix2f> {
+	constructor(
+		c00: Float = 1f, c01: Float = 0f,
+		c10: Float = 0f, c11: Float = 1f,
+	) : super(2, 2, Float2Dimensional(2, 2).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+	})
+
+	private constructor(memory: Float2Dimensional) : super(2, 2, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Float2Dimensional): Matrix2f {
+		requireSizeEquals(memory)
+		return Matrix2f(memory)
+	}
+
+	override val c00: Float get() = memory[0, 0]
+	override val c10: Float get() = memory[1, 0]
+	override val c01: Float get() = memory[0, 1]
+	override val c11: Float get() = memory[1, 1]
+
+	override val r00 by this::c00
+	override val r01 by this::c10
+	override val r10 by this::c01
+	override val r11 by this::c11
+
+	override val a11 by this::c00
+	override val a21 by this::c01
+	override val a12 by this::c10
+	override val a22 by this::c11
+
+	override val b11 by this::c00
+	override val b21 by this::c10
+	override val b12 by this::c01
+	override val b22 by this::c11
+
+	override val c0: Vector2f get() = Vector2f(c00, c01)
+	override val c1: Vector2f get() = Vector2f(c10, c11)
+
+	override val r0: Vector2f get() = Vector2f(r00, r01)
+	override val r1: Vector2f get() = Vector2f(r10, r11)
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Float = 1f, r01: Float = 0f,
+			r10: Float = 0f, r11: Float = 1f,
+		): Matrix2f {
+			return Matrix2f(
+				c00 = r00, c10 = r01,
+				c01 = r10, c11 = r11,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 *
+		 * Since [Matrix2f] is immutable, it is encouraged you use [ZERO] property instead.
+		 */
+		fun zero(): Matrix2f {
+			return Matrix2f(
+				c00 = 0f, c10 = 0f,
+				c01 = 0f, c11 = 0f,
+			)
+		}
+
+		/**
+		 * All values of this matrix are zero
+		 */
+		@JvmField val ZERO = zero()
+
+		/**
+		 * Main diagonal of this matrix is 1s
+		 */
+		@JvmField val IDENTITY = Matrix2f()
+	}
+}
+
+/**
+ * Represents mutable concrete matrix with 2x2 dimensions, storing values as [Double]s.
+ *
+ * See [MutableMatrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [MutableVector2f], generic interface is represented by [IMatrix2f].
+ */
+class MutableMatrix2f : AbstractMutableMatrixVf<MutableMatrix2f>, IMatrix2f<MutableMatrix2f> {
+	constructor(
+		c00: Float = 1f, c01: Float = 0f,
+		c10: Float = 0f, c11: Float = 1f,
+	) : super(2, 2, Float2Dimensional(2, 2).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+	})
+
+	private constructor(memory: Float2Dimensional) : super(2, 2, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Float2Dimensional): MutableMatrix2f {
+		requireSizeEquals(memory)
+		return MutableMatrix2f(memory)
+	}
+
+
+	override var c00: Float
+		get() = memory[0, 0]
+		set(value) { memory[0, 0] = value }
+	override var c10: Float
+		get() = memory[1, 0]
+		set(value) { memory[1, 0] = value }
+	override var c01: Float
+		get() = memory[0, 1]
+		set(value) { memory[0, 1] = value }
+	override var c11: Float
+		get() = memory[1, 1]
+		set(value) { memory[1, 1] = value }
+
+	override var r00 by this::c00
+	override var r01 by this::c10
+	override var r10 by this::c01
+	override var r11 by this::c11
+
+	override var a11 by this::c00
+	override var a21 by this::c01
+	override var a12 by this::c10
+	override var a22 by this::c11
+
+	override var b11 by this::c00
+	override var b21 by this::c10
+	override var b12 by this::c01
+	override var b22 by this::c11
+
+	override var c0: Vector2f
+		get() = object : MutableVector2f(c00, c01) {
+			override var x by this@MutableMatrix2f::c00
+			override var y by this@MutableMatrix2f::c01
+		}
+		set(value) {
+			c00 = value.x
+			c01 = value.y
+		}
+	override var c1: Vector2f
+		get() = object : MutableVector2f(c10, c11) {
+			override var x by this@MutableMatrix2f::c10
+			override var y by this@MutableMatrix2f::c11
+		}
+		set(value) {
+			c10 = value.x
+			c11 = value.y
+		}
+
+	override var r0: Vector2f
+		get() = object : MutableVector2f(r00, r01) {
+			override var x by this@MutableMatrix2f::r00
+			override var y by this@MutableMatrix2f::r01
+		}
+		set(value) {
+			r00 = value.x
+			r01 = value.y
+		}
+	override var r1: Vector2f
+		get() = object : MutableVector2f(r10, r11) {
+			override var x by this@MutableMatrix2f::r10
+			override var y by this@MutableMatrix2f::r11
+		}
+		set(value) {
+			r10 = value.x
+			r11 = value.y
+		}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Float = 1f, r01: Float = 0f,
+			r10: Float = 0f, r11: Float = 1f,
+		): MutableMatrix2f {
+			return MutableMatrix2f(
+				c00 = r00, c10 = r01,
+				c01 = r10, c11 = r11,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 */
+		fun zero(): MutableMatrix2f {
+			return MutableMatrix2f(
+				c00 = 0f, c10 = 0f,
+				c01 = 0f, c11 = 0f,
+			)
+		}
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/nfloat/Matrix3f.kt

@@ -0,0 +1,394 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.matrix.nfloat
+
+import ru.dbotthepony.kvector.api.IMutableSquareMatrix
+import ru.dbotthepony.kvector.api.concrete.IMatrix3f
+import ru.dbotthepony.kvector.matrix.ndouble.Matrix4d
+import ru.dbotthepony.kvector.matrix.ndouble.MutableMatrix4d
+import ru.dbotthepony.kvector.narray.Float2Dimensional
+import ru.dbotthepony.kvector.vector.nfloat.*
+
+/**
+ * Represents immutable concrete matrix with 3x3 dimensions, storing values as [Float]s.
+ *
+ * See [Matrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [Vector3f], generic interface is represented by [IMatrix3f].
+ */
+class Matrix3f : AbstractMatrixVf<Matrix3f>, IMatrix3f<Matrix3f> {
+	constructor(
+		c00: Float = 1f, c01: Float = 0f, c02: Float = 0f,
+		c10: Float = 0f, c11: Float = 1f, c12: Float = 0f,
+		c20: Float = 0f, c21: Float = 0f, c22: Float = 1f,
+	) : super(3, 3, Float2Dimensional(3, 3).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+		it[2, 0] = c20
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+		it[2, 1] = c21
+
+		it[0, 2] = c02
+		it[1, 2] = c12
+		it[2, 2] = c22
+	})
+
+	private constructor(memory: Float2Dimensional) : super(3, 3, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Float2Dimensional): Matrix3f {
+		requireSizeEquals(memory)
+		return Matrix3f(memory)
+	}
+
+	override val c00: Float get() = memory[0, 0]
+	override val c10: Float get() = memory[1, 0]
+	override val c20: Float get() = memory[2, 0]
+	override val c01: Float get() = memory[0, 1]
+	override val c11: Float get() = memory[1, 1]
+	override val c21: Float get() = memory[2, 1]
+	override val c02: Float get() = memory[0, 2]
+	override val c12: Float get() = memory[1, 2]
+	override val c22: Float get() = memory[2, 2]
+
+	override val r00 by this::c00
+	override val r01 by this::c10
+	override val r02 by this::c20
+	override val r10 by this::c01
+	override val r11 by this::c11
+	override val r12 by this::c21
+	override val r20 by this::c02
+	override val r21 by this::c12
+	override val r22 by this::c22
+
+	override val a11 by this::c00
+	override val a21 by this::c01
+	override val a31 by this::c02
+	override val a12 by this::c10
+	override val a22 by this::c11
+	override val a32 by this::c12
+	override val a13 by this::c20
+	override val a23 by this::c21
+	override val a33 by this::c22
+
+	override val b11 by this::c00
+	override val b21 by this::c10
+	override val b31 by this::c20
+	override val b12 by this::c01
+	override val b22 by this::c11
+	override val b32 by this::c21
+	override val b13 by this::c02
+	override val b23 by this::c12
+	override val b33 by this::c22
+
+	override val c0: Vector3f get() = Vector3f(c00, c01, c02)
+	override val c1: Vector3f get() = Vector3f(c10, c11, c12)
+	override val c2: Vector3f get() = Vector3f(c20, c21, c22)
+
+	override val r0: Vector3f get() = Vector3f(r00, r01, r02)
+	override val r1: Vector3f get() = Vector3f(r10, r11, r12)
+	override val r2: Vector3f get() = Vector3f(r20, r21, r22)
+
+	override fun translate(vector: Vector2f): Matrix3f {
+		return rm(
+			r00, r01, r02 + vector.x,
+			r10, r11, r12 + vector.y,
+			r20, r21, r22,
+		)
+	}
+
+	override fun translateWithMultiplication(vector: Vector2f): Matrix3f {
+		return rm(
+			r00, r01, r02 + vector.x * r00 + vector.y * r01,
+			r10, r11, r12 + vector.x * r10 + vector.y * r11,
+			r20, r21, r22,
+		)
+	}
+
+	override fun scale(vector: Vector2f): Matrix3f {
+		return rm(
+			r00 * vector.x, r01, r02,
+			r10, r11 * vector.y, r12,
+			r20, r21, r22
+		)
+	}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Float = 1f, r01: Float = 0f, r02: Float = 0f,
+			r10: Float = 0f, r11: Float = 1f, r12: Float = 0f,
+			r20: Float = 0f, r21: Float = 0f, r22: Float = 1f,
+		): Matrix3f {
+			return Matrix3f(
+				c00 = r00, c10 = r01, c20 = r02,
+				c01 = r10, c11 = r11, c21 = r12,
+				c02 = r20, c12 = r21, c22 = r22,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 *
+		 * Since [Matrix3f] is immutable, it is encouraged you use [ZERO] property instead.
+		 */
+		fun zero(): Matrix3f {
+			return Matrix3f(
+				c00 = 0f, c10 = 0f, c20 = 0f,
+				c01 = 0f, c11 = 0f, c21 = 0f,
+				c02 = 0f, c12 = 0f, c22 = 0f,
+			)
+		}
+
+		/**
+		 * All values of this matrix are zero
+		 */
+		@JvmField val ZERO = zero()
+
+		/**
+		 * Main diagonal of this matrix is 1s
+		 */
+		@JvmField val IDENTITY = Matrix3f()
+	}
+}
+
+/**
+ * Represents mutable concrete matrix with 3x3 dimensions, storing values as [Float]s.
+ *
+ * See [MutableMatrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [MutableVector3f], generic interface is represented by [IMatrix3f].
+ */
+class MutableMatrix3f : AbstractMutableMatrixVf<MutableMatrix3f>, IMutableSquareMatrix<MutableMatrix3f, Vector2f>, IMatrix3f<MutableMatrix3f> {
+	constructor(
+		c00: Float = 1f, c01: Float = 0f, c02: Float = 0f,
+		c10: Float = 0f, c11: Float = 1f, c12: Float = 0f,
+		c20: Float = 0f, c21: Float = 0f, c22: Float = 1f,
+	) : super(3, 3, Float2Dimensional(3, 3).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+		it[2, 0] = c20
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+		it[2, 1] = c21
+
+		it[0, 2] = c02
+		it[1, 2] = c12
+		it[2, 2] = c22
+	})
+
+	private constructor(memory: Float2Dimensional) : super(3, 3, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Float2Dimensional): MutableMatrix3f {
+		requireSizeEquals(memory)
+		return MutableMatrix3f(memory)
+	}
+
+	override fun translateWithMultiplicationMut(vector: Vector2f): MutableMatrix3f {
+		r02 += vector.x * r00 + vector.y * r01
+		r12 += vector.x * r10 + vector.y * r11
+		return this
+	}
+
+	override fun scaleMut(vector: Vector2f): MutableMatrix3f {
+		r00 *= vector.x
+		r11 *= vector.y
+		return this
+	}
+
+	override var c00: Float
+		get() = memory[0, 0]
+		set(value) { memory[0, 0] = value }
+	override var c10: Float
+		get() = memory[1, 0]
+		set(value) { memory[1, 0] = value }
+	override var c20: Float
+		get() = memory[2, 0]
+		set(value) { memory[2, 0] = value }
+	override var c01: Float
+		get() = memory[0, 1]
+		set(value) { memory[0, 1] = value }
+	override var c11: Float
+		get() = memory[1, 1]
+		set(value) { memory[1, 1] = value }
+	override var c21: Float
+		get() = memory[2, 1]
+		set(value) { memory[2, 1] = value }
+	override var c02: Float
+		get() = memory[0, 2]
+		set(value) { memory[0, 2] = value }
+	override var c12: Float
+		get() = memory[1, 2]
+		set(value) { memory[1, 2] = value }
+	override var c22: Float
+		get() = memory[2, 2]
+		set(value) { memory[2, 2] = value }
+
+	override var r00 by this::c00
+	override var r01 by this::c10
+	override var r02 by this::c20
+	override var r10 by this::c01
+	override var r11 by this::c11
+	override var r12 by this::c21
+	override var r20 by this::c02
+	override var r21 by this::c12
+	override var r22 by this::c22
+
+	override var a11 by this::c00
+	override var a21 by this::c01
+	override var a31 by this::c02
+	override var a12 by this::c10
+	override var a22 by this::c11
+	override var a32 by this::c12
+	override var a13 by this::c20
+	override var a23 by this::c21
+	override var a33 by this::c22
+
+	override var b11 by this::c00
+	override var b21 by this::c10
+	override var b31 by this::c20
+	override var b12 by this::c01
+	override var b22 by this::c11
+	override var b32 by this::c21
+	override var b13 by this::c02
+	override var b23 by this::c12
+	override var b33 by this::c22
+
+	override var translation: Vector2f
+		get() = super.translation
+		set(value) {
+			r02 = value.x
+			r12 = value.y
+		}
+
+	override var c0: Vector3f
+		get() = object : MutableVector3f(c00, c01, c02) {
+			override var x by this@MutableMatrix3f::c00
+			override var y by this@MutableMatrix3f::c01
+			override var z by this@MutableMatrix3f::c02
+		}
+		set(value) {
+			c00 = value.x
+			c01 = value.y
+			c02 = value.z
+		}
+	override var c1: Vector3f
+		get() = object : MutableVector3f(c10, c11, c12) {
+			override var x by this@MutableMatrix3f::c10
+			override var y by this@MutableMatrix3f::c11
+			override var z by this@MutableMatrix3f::c12
+		}
+		set(value) {
+			c10 = value.x
+			c11 = value.y
+			c12 = value.z
+		}
+	override var c2: Vector3f
+		get() = object : MutableVector3f(c20, c21, c22) {
+			override var x by this@MutableMatrix3f::c20
+			override var y by this@MutableMatrix3f::c21
+			override var z by this@MutableMatrix3f::c22
+		}
+		set(value) {
+			c20 = value.x
+			c21 = value.y
+			c22 = value.z
+		}
+
+	override var r0: Vector3f
+		get() = object : MutableVector3f(r00, r01, r02) {
+			override var x by this@MutableMatrix3f::r00
+			override var y by this@MutableMatrix3f::r01
+			override var z by this@MutableMatrix3f::r02
+		}
+		set(value) {
+			r00 = value.x
+			r01 = value.y
+			r02 = value.z
+		}
+	override var r1: Vector3f
+		get() = object : MutableVector3f(r10, r11, r12) {
+			override var x by this@MutableMatrix3f::r10
+			override var y by this@MutableMatrix3f::r11
+			override var z by this@MutableMatrix3f::r12
+		}
+		set(value) {
+			r10 = value.x
+			r11 = value.y
+			r12 = value.z
+		}
+	override var r2: Vector3f
+		get() = object : MutableVector3f(r20, r21, r22) {
+			override var x by this@MutableMatrix3f::r20
+			override var y by this@MutableMatrix3f::r21
+			override var z by this@MutableMatrix3f::r22
+		}
+		set(value) {
+			r20 = value.x
+			r21 = value.y
+			r22 = value.z
+		}
+
+	override fun translate(vector: Vector2f): MutableMatrix3f {
+		return rm(
+			r00, r01, r02 + vector.x,
+			r10, r11, r12 + vector.y,
+			r20, r21, r22,
+		)
+	}
+
+	override fun translateWithMultiplication(vector: Vector2f): MutableMatrix3f {
+		return rm(
+			r00, r01, r02 + vector.x * r00 + vector.y * r01,
+			r10, r11, r12 + vector.x * r10 + vector.y * r11,
+			r20, r21, r22,
+		)
+	}
+
+	override fun scale(vector: Vector2f): MutableMatrix3f {
+		return rm(
+			r00 * vector.x, r01, r02,
+			r10, r11 * vector.y, r12,
+			r20, r21, r22
+		)
+	}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Float = 1f, r01: Float = 0f, r02: Float = 0f,
+			r10: Float = 0f, r11: Float = 1f, r12: Float = 0f,
+			r20: Float = 0f, r21: Float = 0f, r22: Float = 1f,
+		): MutableMatrix3f {
+			return MutableMatrix3f(
+				c00 = r00, c10 = r01, c20 = r02,
+				c01 = r10, c11 = r11, c21 = r12,
+				c02 = r20, c12 = r21, c22 = r22,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 */
+		fun zero(): MutableMatrix3f {
+			return MutableMatrix3f(
+				c00 = 0f, c10 = 0f, c20 = 0f,
+				c01 = 0f, c11 = 0f, c21 = 0f,
+				c02 = 0f, c12 = 0f, c22 = 0f,
+			)
+		}
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/nfloat/Matrix4f.kt

@@ -0,0 +1,543 @@
+
+@file:Suppress("unused")
+
+package ru.dbotthepony.kvector.matrix.nfloat
+
+import ru.dbotthepony.kvector.api.IMutableSquareMatrix
+import ru.dbotthepony.kvector.api.concrete.IMatrix4f
+import ru.dbotthepony.kvector.matrix.ndouble.Matrix4d
+import ru.dbotthepony.kvector.matrix.ndouble.MutableMatrix4d
+import ru.dbotthepony.kvector.narray.Float2Dimensional
+import ru.dbotthepony.kvector.vector.nfloat.*
+
+/**
+ * Represents immutable concrete matrix with 4x4 dimensions, storing values as [Float]s.
+ *
+ * See [Matrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [Vector4f], generic interface is represented by [IMatrix4f].
+ */
+class Matrix4f : AbstractMatrixVf<Matrix4f>, IMatrix4f<Matrix4f> {
+	constructor(
+		c00: Float = 1f, c01: Float = 0f, c02: Float = 0f, c03: Float = 0f,
+		c10: Float = 0f, c11: Float = 1f, c12: Float = 0f, c13: Float = 0f,
+		c20: Float = 0f, c21: Float = 0f, c22: Float = 1f, c23: Float = 0f,
+		c30: Float = 0f, c31: Float = 0f, c32: Float = 0f, c33: Float = 1f,
+	) : super(4, 4, Float2Dimensional(4, 4).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+		it[2, 0] = c20
+		it[3, 0] = c30
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+		it[2, 1] = c21
+		it[3, 1] = c31
+
+		it[0, 2] = c02
+		it[1, 2] = c12
+		it[2, 2] = c22
+		it[3, 2] = c32
+
+		it[0, 3] = c03
+		it[1, 3] = c13
+		it[2, 3] = c23
+		it[3, 3] = c33
+	})
+
+	private constructor(memory: Float2Dimensional) : super(4, 4, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Float2Dimensional): Matrix4f {
+		requireSizeEquals(memory)
+		return Matrix4f(memory)
+	}
+
+	override val c00: Float get() = memory[0, 0]
+	override val c10: Float get() = memory[1, 0]
+	override val c20: Float get() = memory[2, 0]
+	override val c30: Float get() = memory[3, 0]
+	override val c01: Float get() = memory[0, 1]
+	override val c11: Float get() = memory[1, 1]
+	override val c21: Float get() = memory[2, 1]
+	override val c31: Float get() = memory[3, 1]
+	override val c02: Float get() = memory[0, 2]
+	override val c12: Float get() = memory[1, 2]
+	override val c22: Float get() = memory[2, 2]
+	override val c32: Float get() = memory[3, 2]
+	override val c03: Float get() = memory[0, 3]
+	override val c13: Float get() = memory[1, 3]
+	override val c23: Float get() = memory[2, 3]
+	override val c33: Float get() = memory[3, 3]
+
+	override val r00 by this::c00
+	override val r01 by this::c10
+	override val r02 by this::c20
+	override val r03 by this::c30
+	override val r10 by this::c01
+	override val r11 by this::c11
+	override val r12 by this::c21
+	override val r13 by this::c31
+	override val r20 by this::c02
+	override val r21 by this::c12
+	override val r22 by this::c22
+	override val r23 by this::c32
+	override val r30 by this::c03
+	override val r31 by this::c13
+	override val r32 by this::c23
+	override val r33 by this::c33
+
+	override val a11 by this::c00
+	override val a21 by this::c01
+	override val a31 by this::c02
+	override val a41 by this::c03
+	override val a12 by this::c10
+	override val a22 by this::c11
+	override val a32 by this::c12
+	override val a42 by this::c13
+	override val a13 by this::c20
+	override val a23 by this::c21
+	override val a33 by this::c22
+	override val a43 by this::c23
+	override val a14 by this::c30
+	override val a24 by this::c31
+	override val a34 by this::c32
+	override val a44 by this::c33
+
+	override val b11 by this::c00
+	override val b21 by this::c10
+	override val b31 by this::c20
+	override val b41 by this::c30
+	override val b12 by this::c01
+	override val b22 by this::c11
+	override val b32 by this::c21
+	override val b42 by this::c31
+	override val b13 by this::c02
+	override val b23 by this::c12
+	override val b33 by this::c22
+	override val b43 by this::c32
+	override val b14 by this::c03
+	override val b24 by this::c13
+	override val b34 by this::c23
+	override val b44 by this::c33
+
+	override val c0: Vector4f get() = Vector4f(c00, c01, c02, c03)
+	override val c1: Vector4f get() = Vector4f(c10, c11, c12, c13)
+	override val c2: Vector4f get() = Vector4f(c20, c21, c22, c23)
+	override val c3: Vector4f get() = Vector4f(c30, c31, c32, c33)
+
+	override val r0: Vector4f get() = Vector4f(r00, r01, r02, r03)
+	override val r1: Vector4f get() = Vector4f(r10, r11, r12, r13)
+	override val r2: Vector4f get() = Vector4f(r20, r21, r22, r23)
+	override val r3: Vector4f get() = Vector4f(r30, r31, r32, r33)
+
+	override fun translate(vector: Vector3f): Matrix4f {
+		return rm(
+			r00, r01, r02, r03 + vector.x,
+			r10, r11, r12, r13 + vector.y,
+			r20, r21, r22, r23 + vector.z,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun translateWithMultiplication(vector: Vector3f): Matrix4f {
+		return rm(
+			r00, r01, r02, r03 + vector.x * r00 + vector.y * r01 + vector.z * r02,
+			r10, r11, r12, r13 + vector.x * r10 + vector.y * r11 + vector.z * r12,
+			r20, r21, r22, r23 + vector.x * r20 + vector.y * r21 + vector.z * r22,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun scale(vector: Vector3f): Matrix4f {
+		return rm(
+			r00 * vector.x, r01, r02, r03,
+			r10, r11 * vector.y, r12, r13,
+			r20, r21, r22 * vector.z, r23,
+			r30, r31, r32, r33,
+		)
+	}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Float = 1f, r01: Float = 0f, r02: Float = 0f, r03: Float = 0f,
+			r10: Float = 0f, r11: Float = 1f, r12: Float = 0f, r13: Float = 0f,
+			r20: Float = 0f, r21: Float = 0f, r22: Float = 1f, r23: Float = 0f,
+			r30: Float = 0f, r31: Float = 0f, r32: Float = 0f, r33: Float = 1f,
+		): Matrix4f {
+			return Matrix4f(
+				c00 = r00, c10 = r01, c20 = r02, c30 = r03,
+				c01 = r10, c11 = r11, c21 = r12, c31 = r13,
+				c02 = r20, c12 = r21, c22 = r22, c32 = r23,
+				c03 = r30, c13 = r31, c23 = r32, c33 = r33,
+			)
+		}
+
+		/**
+		 * Initializes new zero matrix.
+		 *
+		 * Since [Matrix4f] is immutable, it is encouraged you use [ZERO] property instead.
+		 */
+		fun zero(): Matrix4f {
+			return Matrix4f(
+				c00 = 0f, c10 = 0f, c20 = 0f, c30 = 0f,
+				c01 = 0f, c11 = 0f, c21 = 0f, c31 = 0f,
+				c02 = 0f, c12 = 0f, c22 = 0f, c32 = 0f,
+				c03 = 0f, c13 = 0f, c23 = 0f, c33 = 0f,
+			)
+		}
+
+		/**
+		 * All values of this matrix are zero
+		 */
+		@JvmField val ZERO = zero()
+
+		/**
+		 * Main diagonal of this matrix is 1s
+		 */
+		@JvmField val IDENTITY = Matrix4f()
+	}
+}
+
+/**
+ * Represents mutable concrete matrix with 4x4 dimensions, storing values as [Float]s.
+ *
+ * See [MutableMatrix4d] for documentation, with reflection of this class.
+ *
+ * Vectorized access use [MutableVector4f], generic interface is represented by [IMatrix4f].
+ */
+class MutableMatrix4f : AbstractMutableMatrixVf<MutableMatrix4f>, IMatrix4f<MutableMatrix4f>, IMutableSquareMatrix<MutableMatrix4f, Vector3f> {
+	constructor(
+		c00: Float = 1f, c01: Float = 0f, c02: Float = 0f, c03: Float = 0f,
+		c10: Float = 0f, c11: Float = 1f, c12: Float = 0f, c13: Float = 0f,
+		c20: Float = 0f, c21: Float = 0f, c22: Float = 1f, c23: Float = 0f,
+		c30: Float = 0f, c31: Float = 0f, c32: Float = 0f, c33: Float = 1f,
+	) : super(4, 4, Float2Dimensional(4, 4).also {
+		it[0, 0] = c00
+		it[1, 0] = c10
+		it[2, 0] = c20
+		it[3, 0] = c30
+
+		it[0, 1] = c01
+		it[1, 1] = c11
+		it[2, 1] = c21
+		it[3, 1] = c31
+
+		it[0, 2] = c02
+		it[1, 2] = c12
+		it[2, 2] = c22
+		it[3, 2] = c32
+
+		it[0, 3] = c03
+		it[1, 3] = c13
+		it[2, 3] = c23
+		it[3, 3] = c33
+	})
+
+	private constructor(memory: Float2Dimensional) : super(4, 4, memory)
+
+	override val flexible: Boolean = false
+
+	override fun factorize(memory: Float2Dimensional): MutableMatrix4f {
+		requireSizeEquals(memory)
+		return MutableMatrix4f(memory)
+	}
+
+	override fun translate(vector: Vector3f): MutableMatrix4f {
+		return rm(
+			r00, r01, r02, r03 + vector.x,
+			r10, r11, r12, r13 + vector.y,
+			r20, r21, r22, r23 + vector.z,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun translateWithMultiplication(vector: Vector3f): MutableMatrix4f {
+		return rm(
+			r00, r01, r02, r03 + vector.x * r00 + vector.y * r01 + vector.z * r02,
+			r10, r11, r12, r13 + vector.x * r10 + vector.y * r11 + vector.z * r12,
+			r20, r21, r22, r23 + vector.x * r20 + vector.y * r21 + vector.z * r22,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun scale(vector: Vector3f): MutableMatrix4f {
+		return rm(
+			r00 * vector.x, r01, r02, r03,
+			r10, r11 * vector.y, r12, r13,
+			r20, r21, r22 * vector.z, r23,
+			r30, r31, r32, r33,
+		)
+	}
+
+	override fun translateWithMultiplicationMut(vector: Vector3f): MutableMatrix4f {
+		r03 += vector.x * r00 + vector.y * r01 + vector.z * r02
+		r13 += vector.x * r10 + vector.y * r11 + vector.z * r12
+		r23 += vector.x * r20 + vector.y * r21 + vector.z * r22
+		return this
+	}
+
+	override fun scaleMut(vector: Vector3f): MutableMatrix4f {
+		c00 *= vector.x
+		c11 *= vector.y
+		c22 *= vector.z
+		return this
+	}
+
+	override var translation: Vector3f
+		get() = super.translation
+		set(value) {
+			r03 = value.x
+			r13 = value.y
+			r23 = value.z
+		}
+
+	override var c00: Float
+		get() = memory[0, 0]
+		set(value) { memory[0, 0] = value }
+	override var c10: Float
+		get() = memory[1, 0]
+		set(value) { memory[1, 0] = value }
+	override var c20: Float
+		get() = memory[2, 0]
+		set(value) { memory[2, 0] = value }
+	override var c30: Float
+		get() = memory[3, 0]
+		set(value) { memory[3, 0] = value }
+	override var c01: Float
+		get() = memory[0, 1]
+		set(value) { memory[0, 1] = value }
+	override var c11: Float
+		get() = memory[1, 1]
+		set(value) { memory[1, 1] = value }
+	override var c21: Float
+		get() = memory[2, 1]
+		set(value) { memory[2, 1] = value }
+	override var c31: Float
+		get() = memory[3, 1]
+		set(value) { memory[3, 1] = value }
+	override var c02: Float
+		get() = memory[0, 2]
+		set(value) { memory[0, 2] = value }
+	override var c12: Float
+		get() = memory[1, 2]
+		set(value) { memory[1, 2] = value }
+	override var c22: Float
+		get() = memory[2, 2]
+		set(value) { memory[2, 2] = value }
+	override var c32: Float
+		get() = memory[3, 2]
+		set(value) { memory[3, 2] = value }
+	override var c03: Float
+		get() = memory[0, 3]
+		set(value) { memory[0, 3] = value }
+	override var c13: Float
+		get() = memory[1, 3]
+		set(value) { memory[1, 3] = value }
+	override var c23: Float
+		get() = memory[2, 3]
+		set(value) { memory[2, 3] = value }
+	override var c33: Float
+		get() = memory[3, 3]
+		set(value) { memory[3, 3] = value }
+
+	override var r00 by this::c00
+	override var r01 by this::c10
+	override var r02 by this::c20
+	override var r03 by this::c30
+	override var r10 by this::c01
+	override var r11 by this::c11
+	override var r12 by this::c21
+	override var r13 by this::c31
+	override var r20 by this::c02
+	override var r21 by this::c12
+	override var r22 by this::c22
+	override var r23 by this::c32
+	override var r30 by this::c03
+	override var r31 by this::c13
+	override var r32 by this::c23
+	override var r33 by this::c33
+
+	override var a11 by this::c00
+	override var a21 by this::c01
+	override var a31 by this::c02
+	override var a41 by this::c03
+	override var a12 by this::c10
+	override var a22 by this::c11
+	override var a32 by this::c12
+	override var a42 by this::c13
+	override var a13 by this::c20
+	override var a23 by this::c21
+	override var a33 by this::c22
+	override var a43 by this::c23
+	override var a14 by this::c30
+	override var a24 by this::c31
+	override var a34 by this::c32
+	override var a44 by this::c33
+
+	override var b11 by this::c00
+	override var b21 by this::c01
+	override var b31 by this::c02
+	override var b41 by this::c03
+	override var b12 by this::c10
+	override var b22 by this::c11
+	override var b32 by this::c12
+	override var b42 by this::c13
+	override var b13 by this::c20
+	override var b23 by this::c21
+	override var b33 by this::c22
+	override var b43 by this::c23
+	override var b14 by this::c30
+	override var b24 by this::c31
+	override var b34 by this::c32
+	override var b44 by this::c33
+
+	override var c0: Vector4f
+		get() = object : MutableVector4f(c00, c01, c02, c03) {
+			override var x by this@MutableMatrix4f::c00
+			override var y by this@MutableMatrix4f::c01
+			override var z by this@MutableMatrix4f::c02
+			override var w by this@MutableMatrix4f::c03
+		}
+		set(value) {
+			c00 = value.x
+			c01 = value.y
+			c02 = value.z
+			c03 = value.w
+		}
+
+	override var c1: Vector4f
+		get() = object : MutableVector4f(c10, c11, c12, c13) {
+			override var x by this@MutableMatrix4f::c10
+			override var y by this@MutableMatrix4f::c11
+			override var z by this@MutableMatrix4f::c12
+			override var w by this@MutableMatrix4f::c13
+		}
+		set(value) {
+			c10 = value.x
+			c11 = value.y
+			c12 = value.z
+			c13 = value.w
+		}
+
+	override var c2: Vector4f
+		get() = object : MutableVector4f(c20, c21, c22, c23) {
+			override var x by this@MutableMatrix4f::c20
+			override var y by this@MutableMatrix4f::c21
+			override var z by this@MutableMatrix4f::c22
+			override var w by this@MutableMatrix4f::c23
+		}
+		set(value) {
+			c20 = value.x
+			c21 = value.y
+			c22 = value.z
+			c23 = value.w
+		}
+
+	override var c3: Vector4f
+		get() = object : MutableVector4f(c30, c31, c32, c33) {
+			override var x by this@MutableMatrix4f::c30
+			override var y by this@MutableMatrix4f::c31
+			override var z by this@MutableMatrix4f::c32
+			override var w by this@MutableMatrix4f::c33
+		}
+		set(value) {
+			c30 = value.x
+			c31 = value.y
+			c32 = value.z
+			c33 = value.w
+		}
+
+	override var r0: Vector4f
+		get() = object : MutableVector4f(r00, r01, r02, r03) {
+			override var x by this@MutableMatrix4f::r00
+			override var y by this@MutableMatrix4f::r01
+			override var z by this@MutableMatrix4f::r02
+			override var w by this@MutableMatrix4f::r03
+		}
+		set(value) {
+			r00 = value.x
+			r01 = value.y
+			r02 = value.z
+			r03 = value.w
+		}
+
+	override var r1: Vector4f
+		get() = object : MutableVector4f(r10, r11, r12, r13) {
+			override var x by this@MutableMatrix4f::r10
+			override var y by this@MutableMatrix4f::r11
+			override var z by this@MutableMatrix4f::r12
+			override var w by this@MutableMatrix4f::r13
+		}
+		set(value) {
+			r10 = value.x
+			r11 = value.y
+			r12 = value.z
+			r13 = value.w
+		}
+
+	override var r2: Vector4f
+		get() = object : MutableVector4f(r20, r21, r22, r23) {
+			override var x by this@MutableMatrix4f::r20
+			override var y by this@MutableMatrix4f::r21
+			override var z by this@MutableMatrix4f::r22
+			override var w by this@MutableMatrix4f::r23
+		}
+		set(value) {
+			r20 = value.x
+			r21 = value.y
+			r22 = value.z
+			r23 = value.w
+		}
+
+	override var r3: Vector4f
+		get() = object : MutableVector4f(r30, r31, r32, r33) {
+			override var x by this@MutableMatrix4f::r30
+			override var y by this@MutableMatrix4f::r31
+			override var z by this@MutableMatrix4f::r32
+			override var w by this@MutableMatrix4f::r33
+		}
+		set(value) {
+			r30 = value.x
+			r31 = value.y
+			r32 = value.z
+			r33 = value.w
+		}
+
+	companion object {
+		/**
+		 * Initializes new matrix, with arguments taken in *Row-Major* order, that is, fist row of values
+		 * is fist row in created matrix.
+		 */
+		fun rm(
+			r00: Float = 1f, r01: Float = 0f, r02: Float = 0f, r03: Float = 0f,
+			r10: Float = 0f, r11: Float = 1f, r12: Float = 0f, r13: Float = 0f,
+			r20: Float = 0f, r21: Float = 0f, r22: Float = 1f, r23: Float = 0f,
+			r30: Float = 0f, r31: Float = 0f, r32: Float = 0f, r33: Float = 1f,
+		): MutableMatrix4f {
+			return MutableMatrix4f(
+				c00 = r00, c10 = r01, c20 = r02, c30 = r03,
+				c01 = r10, c11 = r11, c21 = r12, c31 = r13,
+				c02 = r20, c12 = r21, c22 = r22, c32 = r23,
+				c03 = r30, c13 = r31, c23 = r32, c33 = r33,
+			)
+		}
+
+		/**
+		 * Initializes new mutable zero matrix.
+		 */
+		fun zero(): MutableMatrix4f {
+			return MutableMatrix4f(
+				c00 = 0f, c10 = 0f, c20 = 0f, c30 = 0f,
+				c01 = 0f, c11 = 0f, c21 = 0f, c31 = 0f,
+				c02 = 0f, c12 = 0f, c22 = 0f, c32 = 0f,
+				c03 = 0f, c13 = 0f, c23 = 0f, c33 = 0f,
+			)
+		}
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/matrix/nfloat/MatrixVf.kt

@@ -0,0 +1,316 @@
+
+@file:Suppress("unchecked_cast", "unused")
+
+package ru.dbotthepony.kvector.matrix.nfloat
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.matrix.generated.MultiplicationsFloat
+import ru.dbotthepony.kvector.matrix.matrixDeterminant
+import ru.dbotthepony.kvector.matrix.multiplyMatrix
+import ru.dbotthepony.kvector.matrix.transposeMatrix
+import ru.dbotthepony.kvector.narray.Float2Dimensional
+
+private fun checkRows(value: Int): Int {
+	require(value > 0) { "Invalid amount of rows $value" }
+	return value
+}
+
+private fun checkColumns(value: Int): Int {
+	require(value > 0) { "Invalid amount of columns $value" }
+	return value
+}
+
+/**
+ * Abstract class with only one protected abstract method: [factorize].
+ *
+ * This class is meant to be only internally overridden (to implement interfaces), but if you really need to, you can
+ * extend this class.
+ */
+abstract class AbstractMatrixVf<T : AbstractMatrixVf<T>> protected constructor(
+	final override val columns: Int,
+	final override val rows: Int,
+	@JvmField protected val memory: Float2Dimensional
+) : IMatrix<T>, IFloatMatrix<T>, ITransposable<T> {
+	/**
+	 * To avoid middle-object creation when deriving from [AbstractMatrixVf] ([MatrixVf]), this method
+	 * allows to factory produce new instances of final class
+	 */
+	protected abstract fun factorize(memory: Float2Dimensional): T
+	protected open val flexible = true
+
+	final override fun get(column: Int, row: Int): Float {
+		return memory[column, row]
+	}
+
+	override fun plus(other: IMatrixGetterFloat): T {
+		requireSizeEquals(other)
+
+		val result = Float2Dimensional(columns, rows)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				result[column, row] = memory[column, row] + other[column, row]
+			}
+		}
+
+		return factorize(result)
+	}
+
+	override fun minus(other: IMatrixGetterFloat): T {
+		requireSizeEquals(other)
+
+		val result = Float2Dimensional(columns, rows)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				result[column, row] = memory[column, row] - other[column, row]
+			}
+		}
+
+		return factorize(result)
+	}
+
+	override fun times(other: IMatrixGetterFloat): T {
+		require(flexible || sizeEquals(other)) { "${this::class.qualifiedName} is not a flexible" }
+		val result = multiplyMatrix(this, other)
+		return factorize(result)
+	}
+
+	override fun times(other: Float): T {
+		val result = Float2Dimensional(columns, rows)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				result[column, row] = memory[column, row] * other
+			}
+		}
+
+		return factorize(result)
+	}
+
+	override fun div(other: Float): T {
+		val result = Float2Dimensional(columns, rows)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				result[column, row] = memory[column, row] / other
+			}
+		}
+
+		return factorize(result)
+	}
+
+	override val transposed: T
+		get() {
+			val result = transposeMatrix(this)
+			return factorize(result)
+		}
+
+	override val trace: Float?
+		get() {
+			if (!isSquareMatrix)
+				return null
+
+			var calc = 0f
+
+			for (i in 0 until rows) {
+				calc += memory[columns, rows]
+			}
+
+			return calc
+		}
+
+	override val determinant: Float?
+		get() {
+			if (!isSquareMatrix)
+				return null
+
+			return matrixDeterminant(this)
+		}
+
+	override val isFinite: Boolean
+		get() {
+			for (column in 0 until columns) {
+				for (row in 0 until rows) {
+					if (!memory[column, row].isFinite()) {
+						return false
+					}
+				}
+			}
+
+			return true
+		}
+
+	override val isNaN: Boolean
+		get() {
+			for (column in 0 until columns) {
+				for (row in 0 until rows) {
+					if (memory[column, row].isNaN()) {
+						return true
+					}
+				}
+			}
+
+			return false
+		}
+}
+
+/**
+ * Abstract class inheriting [AbstractMatrixVf], implementing mutating methods.
+ *
+ * This class is meant to be only internally overridden (to implement interfaces), but if you really need to, you can
+ * extend this class.
+ */
+abstract class AbstractMutableMatrixVf<T : AbstractMutableMatrixVf<T>> protected constructor(
+	columns: Int,
+	rows: Int,
+	memory: Float2Dimensional
+) : AbstractMatrixVf<T>(columns, rows, memory), IMutableFloatMatrix<T>, IMutableTransposable<T> {
+	final override fun set(column: Int, row: Int, value: Float) {
+		memory[column, row] = value
+	}
+
+	override fun timesMut(other: Float): T {
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] *= other
+			}
+		}
+
+		return this as T
+	}
+
+	override fun divMut(other: Float): T {
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] /= other
+			}
+		}
+
+		return this as T
+	}
+
+	override fun timesMut(other: IMatrixGetterFloat): T {
+		requireSizeEquals(other)
+
+		if (MultiplicationsFloat.multiplyMatrix(this, other, this) == null) {
+			val result = multiplyMatrix(this, other)
+
+			for (column in 0 until columns) {
+				for (row in 0 until rows) {
+					memory[column, row] = result[column, row]
+				}
+			}
+		}
+
+		return this as T
+	}
+
+	override fun plusMut(other: IMatrixGetterFloat): T {
+		requireSizeEquals(other)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] += other[column, row]
+			}
+		}
+
+		return this as T
+	}
+
+	override fun minusMut(other: IMatrixGetterFloat): T {
+		requireSizeEquals(other)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] -= other[column, row]
+			}
+		}
+
+		return this as T
+	}
+
+	override fun transpose(): T {
+		check(isSquareMatrix) { "This matrix is not a square matrix (${columns}x${rows})" }
+
+		val result = transposeMatrix(this)
+
+		for (column in 0 until columns) {
+			for (row in 0 until rows) {
+				memory[column, row] = result[column, row]
+			}
+		}
+
+		return this as T
+	}
+}
+
+/**
+ * Represents immutable matrix with arbitrary dimensions, storing values as [Float]s,
+ * backed by [Float2Dimensional].
+ *
+ * Matrix is initialized to zeros upon creation.
+ */
+open class MatrixVf protected constructor(
+	columns: Int,
+	rows: Int,
+	memory: Float2Dimensional
+) : AbstractMatrixVf<MatrixVf>(columns, rows, memory) {
+	constructor(columns: Int, rows: Int) : this(checkColumns(columns), checkRows(rows), Float2Dimensional(checkColumns(columns), checkRows(rows)))
+
+	override fun factorize(memory: Float2Dimensional): MatrixVf {
+		return MatrixVf(memory.columns, memory.rows, memory)
+	}
+
+	companion object {
+		/**
+		 * Copies specified matrix into new [MatrixVf]
+		 */
+		fun copy(input: IMatrixGetterFloat): MatrixVf {
+			val memory = Float2Dimensional(input.columns, input.rows)
+
+			for (column in 0 until input.columns) {
+				for (row in 0 until input.rows) {
+					memory[column, row] = input[column, row]
+				}
+			}
+
+			return MatrixVf(input.columns, input.rows, memory)
+		}
+	}
+}
+
+/**
+ * Represents mutable matrix with arbitrary dimensions, storing values as [Float]s,
+ * backed by [Float2Dimensional].
+ *
+ * Matrix is initialized to zeros upon creation.
+ */
+open class MutableMatrixVf protected constructor(
+	columns: Int,
+	rows: Int,
+	memory: Float2Dimensional
+) : AbstractMutableMatrixVf<MutableMatrixVf>(columns, rows, memory) {
+	constructor(columns: Int, rows: Int) : this(checkColumns(columns), checkRows(rows), Float2Dimensional(checkColumns(columns), checkRows(rows)))
+
+	override fun factorize(memory: Float2Dimensional): MutableMatrixVf {
+		return MutableMatrixVf(memory.columns, memory.rows, memory)
+	}
+
+	companion object {
+		/**
+		 * Copies specified matrix into new [MutableMatrixVf]
+		 */
+		fun copy(input: IMatrixGetterFloat): MutableMatrixVf {
+			val memory = Float2Dimensional(input.columns, input.rows)
+
+			for (column in 0 until input.columns) {
+				for (row in 0 until input.rows) {
+					memory[column, row] = input[column, row]
+				}
+			}
+
+			return MutableMatrixVf(input.columns, input.rows, memory)
+		}
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/narray/TwoDimensional.kt

@@ -0,0 +1,210 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.narray
+
+import ru.dbotthepony.kvector.api.*
+
+private inline fun require(condition: Boolean, lazy: () -> Any) {
+	if (!condition) {
+		throw IndexOutOfBoundsException(lazy.invoke().toString())
+	}
+}
+
+/**
+ * Two-dimensional array of [Double]s, backed by primitive [DoubleArray].
+ *
+ * Has two constructors, one is for constructing fresh two-dimensional array, and second is for
+ * viewing already existing array as two-dimensional array.
+ */
+class Double2Dimensional(
+	override val columns: Int,
+	override val rows: Int,
+	@JvmField val memory: DoubleArray,
+	private val offset: Int = 0,
+) : IMatrixGetterDouble, IMatrixSetterDouble {
+	init {
+		require(columns >= 0) { "Tried to create $columns columns" }
+		require(rows >= 0) { "Tried to create $rows rows" }
+		require(memory.size - offset >= columns * rows) { "Provided array (${memory.size}) does not satisfy demands of $offset offset, $columns columns and $rows rows" }
+	}
+
+	constructor(columns: Int, rows: Int) : this(columns, rows, DoubleArray(columns * rows))
+
+	override operator fun get(column: Int, row: Int): Double {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		return memory[offset + column + row * columns]
+	}
+
+	override operator fun set(column: Int, row: Int, value: Double) {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		memory[offset + column + row * columns] = value
+	}
+}
+
+/**
+ * Two-dimensional array of [Float]s, backed by primitive [FloatArray]
+ *
+ * Has two constructors, one is for constructing fresh two-dimensional array, and second is for
+ * viewing already existing array as two-dimensional array.
+ */
+class Float2Dimensional(
+	override val columns: Int,
+	override val rows: Int,
+	@JvmField val memory: FloatArray,
+	private val offset: Int = 0,
+) : IMatrixGetterFloat, IMatrixSetterFloat {
+	init {
+		require(columns >= 0) { "Tried to create $columns columns" }
+		require(rows >= 0) { "Tried to create $rows rows" }
+		require(memory.size - offset >= columns * rows) { "Provided array (${memory.size}) does not satisfy demands of $offset offset, $columns columns and $rows rows" }
+	}
+
+	constructor(columns: Int, rows: Int) : this(columns, rows, FloatArray(columns * rows))
+
+	override operator fun get(column: Int, row: Int): Float {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		return memory[offset + column + row * columns]
+	}
+
+	override operator fun set(column: Int, row: Int, value: Float) {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		memory[offset + column + row * columns] = value
+	}
+}
+
+/**
+ * Two-dimensional array of [Byte]s, backed by primitive [ByteArray]
+ *
+ * Has two constructors, one is for constructing fresh two-dimensional array, and second is for
+ * viewing already existing array as two-dimensional array.
+ */
+class Byte2Dimensional(
+	override val columns: Int,
+	override val rows: Int,
+	@JvmField val memory: ByteArray,
+	private val offset: Int = 0,
+) : IMatrixGetterByte, IMatrixSetterByte {
+	init {
+		require(columns >= 0) { "Tried to create $columns columns" }
+		require(rows >= 0) { "Tried to create $rows rows" }
+		require(memory.size - offset >= columns * rows) { "Provided array (${memory.size}) does not satisfy demands of $offset offset, $columns columns and $rows rows" }
+	}
+
+	constructor(columns: Int, rows: Int) : this(columns, rows, ByteArray(columns * rows))
+
+	override operator fun get(column: Int, row: Int): Byte {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		return memory[offset + column + row * columns]
+	}
+
+	override operator fun set(column: Int, row: Int, value: Byte) {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		memory[offset + column + row * columns] = value
+	}
+}
+
+/**
+ * Two-dimensional array of [Short]s, backed by primitive [ShortArray]
+ *
+ * Has two constructors, one is for constructing fresh two-dimensional array, and second is for
+ * viewing already existing array as two-dimensional array.
+ */
+class Short2Dimensional(
+	override val columns: Int,
+	override val rows: Int,
+	@JvmField val memory: ShortArray,
+	private val offset: Int = 0,
+) : IMatrixGetterShort, IMatrixSetterShort {
+	init {
+		require(columns >= 0) { "Tried to create $columns columns" }
+		require(rows >= 0) { "Tried to create $rows rows" }
+		require(memory.size - offset >= columns * rows) { "Provided array (${memory.size}) does not satisfy demands of $offset offset, $columns columns and $rows rows" }
+	}
+
+	constructor(columns: Int, rows: Int) : this(columns, rows, ShortArray(columns * rows))
+
+	override operator fun get(column: Int, row: Int): Short {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		return memory[offset + column + row * columns]
+	}
+
+	override operator fun set(column: Int, row: Int, value: Short) {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		memory[offset + column + row * columns] = value
+	}
+}
+
+/**
+ * Two-dimensional array of [Int]s, backed by primitive [IntArray]
+ *
+ * Has two constructors, one is for constructing fresh two-dimensional array, and second is for
+ * viewing already existing array as two-dimensional array.
+ */
+class Int2Dimensional(
+	override val columns: Int,
+	override val rows: Int,
+	@JvmField val memory: IntArray,
+	private val offset: Int = 0,
+) : IMatrixGetterInt, IMatrixSetterInt {
+	init {
+		require(columns >= 0) { "Tried to create $columns columns" }
+		require(rows >= 0) { "Tried to create $rows rows" }
+		require(memory.size - offset >= columns * rows) { "Provided array (${memory.size}) does not satisfy demands of $offset offset, $columns columns and $rows rows" }
+	}
+
+	constructor(columns: Int, rows: Int) : this(columns, rows, IntArray(columns * rows))
+
+	override operator fun get(column: Int, row: Int): Int {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		return memory[offset + column + row * columns]
+	}
+
+	override operator fun set(column: Int, row: Int, value: Int) {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		memory[offset + column + row * columns] = value
+	}
+}
+
+/**
+ * Two-dimensional array of [Long]s, backed by primitive [LongArray]
+ *
+ * Has two constructors, one is for constructing fresh two-dimensional array, and second is for
+ * viewing already existing array as two-dimensional array.
+ */
+class Long2Dimensional(
+	override val columns: Int,
+	override val rows: Int,
+	@JvmField val memory: LongArray,
+	private val offset: Int = 0,
+) : IMatrixGetterLong, IMatrixSetterLong {
+	init {
+		require(columns >= 0) { "Tried to create $columns columns" }
+		require(rows >= 0) { "Tried to create $rows rows" }
+		require(memory.size - offset >= columns * rows) { "Provided array (${memory.size}) does not satisfy demands of $offset offset, $columns columns and $rows rows" }
+	}
+
+	constructor(columns: Int, rows: Int) : this(columns, rows, LongArray(columns * rows))
+
+	override operator fun get(column: Int, row: Int): Long {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		return memory[offset + column + row * columns]
+	}
+
+	override operator fun set(column: Int, row: Int, value: Long) {
+		require(column in 0 until columns) { "Column out of bounds: $column" }
+		require(row in 0 until rows) { "Row out of bounds: $row" }
+		memory[offset + column + row * columns] = value
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/vector/ndouble/Vector2d.kt

@@ -0,0 +1,407 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.vector.ndouble
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.vector.nfloat.Vector2f
+import kotlin.math.absoluteValue
+import kotlin.math.pow
+import kotlin.math.sqrt
+
+/**
+ * 2D Vector, representing two-dimensional coordinates as [Double]s
+ */
+open class Vector2d(
+	open val x: Double = 0.0,
+	open val y: Double = 0.0
+) : AbstractVector<Vector2d>(), IFractionalVector<Vector2d>, IDoubleVector<Vector2d>, IStruct2d, IMatrixGetterDouble {
+	final override fun component1() = x
+	final override fun component2() = y
+
+	constructor(input: IStruct2d) : this(input.component1(), input.component2())
+
+	final override fun get(column: Int, row: Int): Double {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		return when (row) {
+			0 -> x
+			1 -> y
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	final override val rows: Int = 2
+	final override val lengthSquared: Double
+		get() = x * x + y * y
+
+	final override val isFinite: Boolean
+		get() = x.isFinite() && y.isFinite()
+	final override val isNaN: Boolean
+		get() = x.isNaN() || y.isNaN()
+
+	open val r by this::x
+	open val g by this::y
+
+	open val s by this::x
+	open val t by this::y
+
+	override fun plus(other: Vector2d): Vector2d {
+		return Vector2d(x + other.x, y + other.y)
+	}
+
+	override fun minus(other: Vector2d): Vector2d {
+		return Vector2d(x - other.x, y - other.y)
+	}
+
+	override fun times(other: Vector2d): Vector2d {
+		return Vector2d(x * other.x, y * other.y)
+	}
+
+	override fun div(other: Vector2d): Vector2d {
+		return Vector2d(x / other.x, y / other.y)
+	}
+
+	override val absoluteValue: Vector2d
+		get() = Vector2d(x.absoluteValue, y.absoluteValue)
+
+	override fun coerceAtMost(maximal: Vector2d): Vector2d {
+		return Vector2d(x.coerceAtMost(maximal.x), y.coerceAtMost(maximal.y))
+	}
+
+	override fun coerceAtLeast(minimal: Vector2d): Vector2d {
+		return Vector2d(x.coerceAtLeast(minimal.x), y.coerceAtLeast(minimal.y))
+	}
+
+	override fun clamp(minimal: Vector2d, maximal: Vector2d): Vector2d {
+		return Vector2d(x.coerceAtLeast(minimal.x).coerceAtMost(maximal.x), y.coerceAtLeast(minimal.y).coerceAtMost(maximal.y))
+	}
+
+	override fun unaryMinus(): Vector2d {
+		return Vector2d(-x, -y)
+	}
+
+	override fun distanceSquared(other: Vector2d): Double {
+		val x = x - other.x
+		val y = y - other.y
+
+		return x * x + y * y
+	}
+
+	override val normalized: Vector2d
+		get() {
+			val len = length
+
+			if (len == 0.0) {
+				return ZERO
+			}
+
+			return Vector2d(x / len, y / len)
+		}
+
+	override fun times(other: Double): Vector2d {
+		return Vector2d(x * other, y * other)
+	}
+
+	override fun div(other: Double): Vector2d {
+		return Vector2d(x / other, y / other)
+	}
+
+	fun times(other: Float): Vector2d {
+		return Vector2d(x * other, y * other)
+	}
+
+	fun div(other: Float): Vector2d {
+		return Vector2d(x / other, y / other)
+	}
+
+	fun times(other: Int): Vector2d {
+		return Vector2d(x * other, y * other)
+	}
+
+	fun div(other: Int): Vector2d {
+		return Vector2d(x / other, y / other)
+	}
+
+	/**
+	 * Calculates vector vector * vector, returning result as [Double]
+	 */
+	fun cross(other: Vector2d): Double {
+		return x * other.y - y * other.x
+	}
+
+	/**
+	 * Calculates 2D cross product between scalar and vector
+	 *
+	 * @return new vector
+	 */
+	fun cross(other: Double): Vector2d {
+		return Vector2d(other * y, -other * x)
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector2d): Double {
+		return other.x * x + other.y * y
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector3d): Double {
+		return other.x * x + other.y * y
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector4d): Double {
+		return other.x * x + other.y * y
+	}
+
+	/**
+	 * Casts components to [Float] and returns new vector as result
+	 */
+	open fun toFloatVector(): Vector2f {
+		return Vector2f(x.toFloat(), y.toFloat())
+	}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as Vector2d
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+
+		return true
+	}
+
+	override fun toString(): String {
+		return "[$x $y]"
+	}
+
+	override fun hashCode(): Int {
+		return 31 * x.hashCode() + y.hashCode()
+	}
+
+	inline val xx get() = Vector2d(x, x)
+	inline val xy get() = Vector2d(x, y)
+	inline val yx get() = Vector2d(y, x)
+	inline val yy get() = Vector2d(y, y)
+	inline val xxx get() = Vector3d(x, x, x)
+	inline val xxy get() = Vector3d(x, x, y)
+	inline val xyx get() = Vector3d(x, y, x)
+	inline val xyy get() = Vector3d(x, y, y)
+	inline val yxx get() = Vector3d(y, x, x)
+	inline val yxy get() = Vector3d(y, x, y)
+	inline val yyx get() = Vector3d(y, y, x)
+	inline val yyy get() = Vector3d(y, y, y)
+	inline val xxxx get() = Vector4d(x, x, x, x)
+	inline val xxxy get() = Vector4d(x, x, x, y)
+	inline val xxyx get() = Vector4d(x, x, y, x)
+	inline val xxyy get() = Vector4d(x, x, y, y)
+	inline val xyxx get() = Vector4d(x, y, x, x)
+	inline val xyxy get() = Vector4d(x, y, x, y)
+	inline val xyyx get() = Vector4d(x, y, y, x)
+	inline val xyyy get() = Vector4d(x, y, y, y)
+	inline val yxxx get() = Vector4d(y, x, x, x)
+	inline val yxxy get() = Vector4d(y, x, x, y)
+	inline val yxyx get() = Vector4d(y, x, y, x)
+	inline val yxyy get() = Vector4d(y, x, y, y)
+	inline val yyxx get() = Vector4d(y, y, x, x)
+	inline val yyxy get() = Vector4d(y, y, x, y)
+	inline val yyyx get() = Vector4d(y, y, y, x)
+	inline val yyyy get() = Vector4d(y, y, y, y)
+	inline val rr get() = Vector2d(r, r)
+	inline val rg get() = Vector2d(r, g)
+	inline val gr get() = Vector2d(g, r)
+	inline val gg get() = Vector2d(g, g)
+	inline val rrr get() = Vector3d(r, r, r)
+	inline val rrg get() = Vector3d(r, r, g)
+	inline val rgr get() = Vector3d(r, g, r)
+	inline val rgg get() = Vector3d(r, g, g)
+	inline val grr get() = Vector3d(g, r, r)
+	inline val grg get() = Vector3d(g, r, g)
+	inline val ggr get() = Vector3d(g, g, r)
+	inline val ggg get() = Vector3d(g, g, g)
+	inline val rrrr get() = Vector4d(r, r, r, r)
+	inline val rrrg get() = Vector4d(r, r, r, g)
+	inline val rrgr get() = Vector4d(r, r, g, r)
+	inline val rrgg get() = Vector4d(r, r, g, g)
+	inline val rgrr get() = Vector4d(r, g, r, r)
+	inline val rgrg get() = Vector4d(r, g, r, g)
+	inline val rggr get() = Vector4d(r, g, g, r)
+	inline val rggg get() = Vector4d(r, g, g, g)
+	inline val grrr get() = Vector4d(g, r, r, r)
+	inline val grrg get() = Vector4d(g, r, r, g)
+	inline val grgr get() = Vector4d(g, r, g, r)
+	inline val grgg get() = Vector4d(g, r, g, g)
+	inline val ggrr get() = Vector4d(g, g, r, r)
+	inline val ggrg get() = Vector4d(g, g, r, g)
+	inline val gggr get() = Vector4d(g, g, g, r)
+	inline val gggg get() = Vector4d(g, g, g, g)
+	inline val ss get() = Vector2d(s, s)
+	inline val st get() = Vector2d(s, t)
+	inline val ts get() = Vector2d(t, s)
+	inline val tt get() = Vector2d(t, t)
+	inline val sss get() = Vector3d(s, s, s)
+	inline val sst get() = Vector3d(s, s, t)
+	inline val sts get() = Vector3d(s, t, s)
+	inline val stt get() = Vector3d(s, t, t)
+	inline val tss get() = Vector3d(t, s, s)
+	inline val tst get() = Vector3d(t, s, t)
+	inline val tts get() = Vector3d(t, t, s)
+	inline val ttt get() = Vector3d(t, t, t)
+	inline val ssss get() = Vector4d(s, s, s, s)
+	inline val ssst get() = Vector4d(s, s, s, t)
+	inline val ssts get() = Vector4d(s, s, t, s)
+	inline val sstt get() = Vector4d(s, s, t, t)
+	inline val stss get() = Vector4d(s, t, s, s)
+	inline val stst get() = Vector4d(s, t, s, t)
+	inline val stts get() = Vector4d(s, t, t, s)
+	inline val sttt get() = Vector4d(s, t, t, t)
+	inline val tsss get() = Vector4d(t, s, s, s)
+	inline val tsst get() = Vector4d(t, s, s, t)
+	inline val tsts get() = Vector4d(t, s, t, s)
+	inline val tstt get() = Vector4d(t, s, t, t)
+	inline val ttss get() = Vector4d(t, t, s, s)
+	inline val ttst get() = Vector4d(t, t, s, t)
+	inline val ttts get() = Vector4d(t, t, t, s)
+	inline val tttt get() = Vector4d(t, t, t, t)
+
+	companion object {
+		@JvmField val ZERO = Vector2d()
+		@JvmField val POSITIVE_X = Vector2d(x = 1.0)
+		@JvmField val NEGATIVE_X = Vector2d(x = -1.0)
+		@JvmField val POSITIVE_Y = Vector2d(y = 1.0)
+		@JvmField val NEGATIVE_Y = Vector2d(y = -1.0)
+	}
+}
+
+fun Double.div(other: Vector2d): Vector2d {
+	return Vector2d(this / other.x, this / other.y)
+}
+
+fun Double.times(other: Vector2d): Vector2d {
+	return Vector2d(this * other.x, this * other.y)
+}
+
+/**
+ * Calculates 2D cross product between scalar and vector
+ *
+ * @return new vector
+ */
+fun Double.cross(other: Vector2d): Vector2d {
+	return Vector2d(-this * other.y, this * other.x)
+}
+
+/**
+ * Mutable 2D Vector, representing two-dimensional coordinates as [Double]s
+ *
+ * It can be safely passed around to methods which expect immutable [Vector2d], **AND** do not store it,
+ * as mutable operations are separated from immutable ones
+ */
+open class MutableVector2d(
+	override var x: Double = 0.0,
+	override var y: Double = 0.0
+) : Vector2d(x, y), IMutableDoubleVector<MutableVector2d>, IMutableFractionalVector<MutableVector2d>, IMutableVector<MutableVector2d, Vector2d>, IMatrixSetterDouble {
+	constructor(input: IStruct2d) : this(input.component1(), input.component2())
+
+	override fun set(column: Int, row: Int, value: Double) {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		when (row) {
+			0 -> x = value
+			1 -> y = value
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	override var r by this::x
+	override val g by this::y
+
+	override val s by this::x
+	override val t by this::y
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as MutableVector2d
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+
+		return true
+	}
+
+	override fun plusMut(other: Vector2d): MutableVector2d {
+		x += other.x
+		y += other.y
+		return this
+	}
+
+	override fun minusMut(other: Vector2d): MutableVector2d {
+		x -= other.x
+		y -= other.y
+		return this
+	}
+
+	override fun timesMut(other: Vector2d): MutableVector2d {
+		x *= other.x
+		y *= other.y
+		return this
+	}
+
+	override fun divMut(other: Vector2d): MutableVector2d {
+		x /= other.x
+		y /= other.y
+		return this
+	}
+
+	override fun normalize(): Double {
+		val len = length
+
+		if (len == 0.0) {
+			return len
+		}
+
+		x /= len
+		y /= len
+
+		return len
+	}
+
+	override fun timesMut(other: Double): MutableVector2d {
+		x *= other
+		y *= other
+		return this
+	}
+
+	override fun divMut(other: Double): MutableVector2d {
+		x /= other
+		y /= other
+		return this
+	}
+
+	/**
+	 * Calculates 2D cross product between scalar and vector,
+	 * writing result into this vector
+	 *
+	 * @return this vector
+	 */
+	fun crossMut(other: Double): Vector2d {
+		val x = x
+		val y = y
+		this.x = other * y
+		this.y = -other * x
+		return this
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/vector/ndouble/Vector3d.kt

@@ -0,0 +1,663 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.vector.ndouble
+
+import ru.dbotthepony.kvector.api.*
+import kotlin.math.absoluteValue
+
+/**
+ * 3D Vector, representing three-dimensional coordinates as [Double]s
+ */
+open class Vector3d(
+	open val x: Double = 0.0,
+	open val y: Double = 0.0,
+	open val z: Double = 0.0,
+) : AbstractVector<Vector3d>(), IFractionalVector<Vector3d>, IDoubleVector<Vector3d>, IStruct3d, IMatrixGetterDouble {
+	final override fun component1() = x
+	final override fun component2() = y
+	final override fun component3() = z
+
+	override fun get(column: Int, row: Int): Double {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		return when (row) {
+			0 -> x
+			1 -> y
+			2 -> z
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	constructor(input: IStruct2d, z: Double = 0.0) : this(input.component1(), input.component2(), z)
+	constructor(x: Double, input: IStruct2d) : this(x, input.component1(), input.component2())
+	constructor(input: IStruct3d) : this(input.component1(), input.component2(), input.component3())
+
+	final override val rows: Int = 3
+	final override val lengthSquared: Double
+		get() = x * x + y * y + z * z
+
+	final override val isFinite: Boolean
+		get() = x.isFinite() && y.isFinite() && z.isFinite()
+	final override val isNaN: Boolean
+		get() = x.isNaN() || y.isNaN() || z.isNaN()
+
+	open val r by this::x
+	open val g by this::y
+	open val b by this::z
+
+	open val s by this::x
+	open val t by this::y
+	open val p by this::z
+
+	override fun plus(other: Vector3d): Vector3d {
+		return Vector3d(
+			x + other.x,
+			y + other.y,
+			z + other.z
+		)
+	}
+
+	override fun minus(other: Vector3d): Vector3d {
+		return Vector3d(x - other.x, y - other.y, z - other.z)
+	}
+
+	override fun times(other: Vector3d): Vector3d {
+		return Vector3d(x * other.x, y * other.y, z * other.z)
+	}
+
+	override fun div(other: Vector3d): Vector3d {
+		return Vector3d(x / other.x, y / other.y, z / other.z)
+	}
+
+	override val absoluteValue: Vector3d
+		get() = Vector3d(x.absoluteValue, y.absoluteValue, z.absoluteValue)
+
+	override fun coerceAtMost(maximal: Vector3d): Vector3d {
+		return Vector3d(
+			x.coerceAtMost(maximal.x),
+			y.coerceAtMost(maximal.y),
+			z.coerceAtMost(maximal.z),
+		)
+	}
+
+	override fun coerceAtLeast(minimal: Vector3d): Vector3d {
+		return Vector3d(
+			x.coerceAtLeast(minimal.x),
+			y.coerceAtLeast(minimal.y),
+			z.coerceAtLeast(minimal.z),
+		)
+	}
+
+	override fun clamp(minimal: Vector3d, maximal: Vector3d): Vector3d {
+		return Vector3d(
+			x.coerceAtLeast(minimal.x).coerceAtMost(maximal.x),
+			y.coerceAtLeast(minimal.y).coerceAtMost(maximal.y),
+			z.coerceAtLeast(minimal.z).coerceAtMost(maximal.z),
+		)
+	}
+
+	override fun unaryMinus(): Vector3d {
+		return Vector3d(-x, -y, -z)
+	}
+
+	override fun distanceSquared(other: Vector3d): Double {
+		val x = x - other.x
+		val y = y - other.y
+		val z = z - other.z
+
+		return x * x + y * y + z * z
+	}
+
+	override val normalized: Vector3d
+		get() {
+			val len = length
+
+			if (len == 0.0) {
+				return ZERO
+			}
+
+			return Vector3d(x / len, y / len, z / len)
+		}
+
+	override fun times(other: Double): Vector3d {
+		return Vector3d(x * other, y * other, z * other)
+	}
+
+	override fun div(other: Double): Vector3d {
+		return Vector3d(x / other, y / other, z / other)
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector4d): Double {
+		return other.x * x + other.y * y + other.z * z
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector3d): Double {
+		return other.x * x + other.y * y + other.z * z
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector2d): Double {
+		return other.x * x + other.y * y
+	}
+
+	/**
+	 * Calculates vector vector * vector, returning result as new vector
+	 */
+	fun cross(other: Vector3d): Vector3d {
+		return Vector3d(
+			y * other.z - z * other.y,
+			z * other.x - x * other.z,
+			x * other.y - y * other.x,
+		)
+	}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as Vector3d
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+		if (z != other.z) return false
+
+		return true
+	}
+
+	override fun toString(): String {
+		return "[$x $y $z]"
+	}
+
+	override fun hashCode(): Int {
+		var result = x.hashCode()
+		result = 31 * result + y.hashCode()
+		result = 31 * result + z.hashCode()
+		return result
+	}
+
+	inline val xx get() = Vector2d(x, x)
+	inline val xy get() = Vector2d(x, y)
+	inline val xz get() = Vector2d(x, z)
+	inline val yx get() = Vector2d(y, x)
+	inline val yy get() = Vector2d(y, y)
+	inline val yz get() = Vector2d(y, z)
+	inline val zx get() = Vector2d(z, x)
+	inline val zy get() = Vector2d(z, y)
+	inline val zz get() = Vector2d(z, z)
+	inline val xxx get() = Vector3d(x, x, x)
+	inline val xxy get() = Vector3d(x, x, y)
+	inline val xxz get() = Vector3d(x, x, z)
+	inline val xyx get() = Vector3d(x, y, x)
+	inline val xyy get() = Vector3d(x, y, y)
+	inline val xyz get() = Vector3d(x, y, z)
+	inline val xzx get() = Vector3d(x, z, x)
+	inline val xzy get() = Vector3d(x, z, y)
+	inline val xzz get() = Vector3d(x, z, z)
+	inline val yxx get() = Vector3d(y, x, x)
+	inline val yxy get() = Vector3d(y, x, y)
+	inline val yxz get() = Vector3d(y, x, z)
+	inline val yyx get() = Vector3d(y, y, x)
+	inline val yyy get() = Vector3d(y, y, y)
+	inline val yyz get() = Vector3d(y, y, z)
+	inline val yzx get() = Vector3d(y, z, x)
+	inline val yzy get() = Vector3d(y, z, y)
+	inline val yzz get() = Vector3d(y, z, z)
+	inline val zxx get() = Vector3d(z, x, x)
+	inline val zxy get() = Vector3d(z, x, y)
+	inline val zxz get() = Vector3d(z, x, z)
+	inline val zyx get() = Vector3d(z, y, x)
+	inline val zyy get() = Vector3d(z, y, y)
+	inline val zyz get() = Vector3d(z, y, z)
+	inline val zzx get() = Vector3d(z, z, x)
+	inline val zzy get() = Vector3d(z, z, y)
+	inline val zzz get() = Vector3d(z, z, z)
+	inline val xxxx get() = Vector4d(x, x, x, x)
+	inline val xxxy get() = Vector4d(x, x, x, y)
+	inline val xxxz get() = Vector4d(x, x, x, z)
+	inline val xxyx get() = Vector4d(x, x, y, x)
+	inline val xxyy get() = Vector4d(x, x, y, y)
+	inline val xxyz get() = Vector4d(x, x, y, z)
+	inline val xxzx get() = Vector4d(x, x, z, x)
+	inline val xxzy get() = Vector4d(x, x, z, y)
+	inline val xxzz get() = Vector4d(x, x, z, z)
+	inline val xyxx get() = Vector4d(x, y, x, x)
+	inline val xyxy get() = Vector4d(x, y, x, y)
+	inline val xyxz get() = Vector4d(x, y, x, z)
+	inline val xyyx get() = Vector4d(x, y, y, x)
+	inline val xyyy get() = Vector4d(x, y, y, y)
+	inline val xyyz get() = Vector4d(x, y, y, z)
+	inline val xyzx get() = Vector4d(x, y, z, x)
+	inline val xyzy get() = Vector4d(x, y, z, y)
+	inline val xyzz get() = Vector4d(x, y, z, z)
+	inline val xzxx get() = Vector4d(x, z, x, x)
+	inline val xzxy get() = Vector4d(x, z, x, y)
+	inline val xzxz get() = Vector4d(x, z, x, z)
+	inline val xzyx get() = Vector4d(x, z, y, x)
+	inline val xzyy get() = Vector4d(x, z, y, y)
+	inline val xzyz get() = Vector4d(x, z, y, z)
+	inline val xzzx get() = Vector4d(x, z, z, x)
+	inline val xzzy get() = Vector4d(x, z, z, y)
+	inline val xzzz get() = Vector4d(x, z, z, z)
+	inline val yxxx get() = Vector4d(y, x, x, x)
+	inline val yxxy get() = Vector4d(y, x, x, y)
+	inline val yxxz get() = Vector4d(y, x, x, z)
+	inline val yxyx get() = Vector4d(y, x, y, x)
+	inline val yxyy get() = Vector4d(y, x, y, y)
+	inline val yxyz get() = Vector4d(y, x, y, z)
+	inline val yxzx get() = Vector4d(y, x, z, x)
+	inline val yxzy get() = Vector4d(y, x, z, y)
+	inline val yxzz get() = Vector4d(y, x, z, z)
+	inline val yyxx get() = Vector4d(y, y, x, x)
+	inline val yyxy get() = Vector4d(y, y, x, y)
+	inline val yyxz get() = Vector4d(y, y, x, z)
+	inline val yyyx get() = Vector4d(y, y, y, x)
+	inline val yyyy get() = Vector4d(y, y, y, y)
+	inline val yyyz get() = Vector4d(y, y, y, z)
+	inline val yyzx get() = Vector4d(y, y, z, x)
+	inline val yyzy get() = Vector4d(y, y, z, y)
+	inline val yyzz get() = Vector4d(y, y, z, z)
+	inline val yzxx get() = Vector4d(y, z, x, x)
+	inline val yzxy get() = Vector4d(y, z, x, y)
+	inline val yzxz get() = Vector4d(y, z, x, z)
+	inline val yzyx get() = Vector4d(y, z, y, x)
+	inline val yzyy get() = Vector4d(y, z, y, y)
+	inline val yzyz get() = Vector4d(y, z, y, z)
+	inline val yzzx get() = Vector4d(y, z, z, x)
+	inline val yzzy get() = Vector4d(y, z, z, y)
+	inline val yzzz get() = Vector4d(y, z, z, z)
+	inline val zxxx get() = Vector4d(z, x, x, x)
+	inline val zxxy get() = Vector4d(z, x, x, y)
+	inline val zxxz get() = Vector4d(z, x, x, z)
+	inline val zxyx get() = Vector4d(z, x, y, x)
+	inline val zxyy get() = Vector4d(z, x, y, y)
+	inline val zxyz get() = Vector4d(z, x, y, z)
+	inline val zxzx get() = Vector4d(z, x, z, x)
+	inline val zxzy get() = Vector4d(z, x, z, y)
+	inline val zxzz get() = Vector4d(z, x, z, z)
+	inline val zyxx get() = Vector4d(z, y, x, x)
+	inline val zyxy get() = Vector4d(z, y, x, y)
+	inline val zyxz get() = Vector4d(z, y, x, z)
+	inline val zyyx get() = Vector4d(z, y, y, x)
+	inline val zyyy get() = Vector4d(z, y, y, y)
+	inline val zyyz get() = Vector4d(z, y, y, z)
+	inline val zyzx get() = Vector4d(z, y, z, x)
+	inline val zyzy get() = Vector4d(z, y, z, y)
+	inline val zyzz get() = Vector4d(z, y, z, z)
+	inline val zzxx get() = Vector4d(z, z, x, x)
+	inline val zzxy get() = Vector4d(z, z, x, y)
+	inline val zzxz get() = Vector4d(z, z, x, z)
+	inline val zzyx get() = Vector4d(z, z, y, x)
+	inline val zzyy get() = Vector4d(z, z, y, y)
+	inline val zzyz get() = Vector4d(z, z, y, z)
+	inline val zzzx get() = Vector4d(z, z, z, x)
+	inline val zzzy get() = Vector4d(z, z, z, y)
+	inline val zzzz get() = Vector4d(z, z, z, z)
+	inline val rr get() = Vector2d(r, r)
+	inline val rg get() = Vector2d(r, g)
+	inline val rb get() = Vector2d(r, b)
+	inline val gr get() = Vector2d(g, r)
+	inline val gg get() = Vector2d(g, g)
+	inline val gb get() = Vector2d(g, b)
+	inline val br get() = Vector2d(b, r)
+	inline val bg get() = Vector2d(b, g)
+	inline val bb get() = Vector2d(b, b)
+	inline val rrr get() = Vector3d(r, r, r)
+	inline val rrg get() = Vector3d(r, r, g)
+	inline val rrb get() = Vector3d(r, r, b)
+	inline val rgr get() = Vector3d(r, g, r)
+	inline val rgg get() = Vector3d(r, g, g)
+	inline val rgb get() = Vector3d(r, g, b)
+	inline val rbr get() = Vector3d(r, b, r)
+	inline val rbg get() = Vector3d(r, b, g)
+	inline val rbb get() = Vector3d(r, b, b)
+	inline val grr get() = Vector3d(g, r, r)
+	inline val grg get() = Vector3d(g, r, g)
+	inline val grb get() = Vector3d(g, r, b)
+	inline val ggr get() = Vector3d(g, g, r)
+	inline val ggg get() = Vector3d(g, g, g)
+	inline val ggb get() = Vector3d(g, g, b)
+	inline val gbr get() = Vector3d(g, b, r)
+	inline val gbg get() = Vector3d(g, b, g)
+	inline val gbb get() = Vector3d(g, b, b)
+	inline val brr get() = Vector3d(b, r, r)
+	inline val brg get() = Vector3d(b, r, g)
+	inline val brb get() = Vector3d(b, r, b)
+	inline val bgr get() = Vector3d(b, g, r)
+	inline val bgg get() = Vector3d(b, g, g)
+	inline val bgb get() = Vector3d(b, g, b)
+	inline val bbr get() = Vector3d(b, b, r)
+	inline val bbg get() = Vector3d(b, b, g)
+	inline val bbb get() = Vector3d(b, b, b)
+	inline val rrrr get() = Vector4d(r, r, r, r)
+	inline val rrrg get() = Vector4d(r, r, r, g)
+	inline val rrrb get() = Vector4d(r, r, r, b)
+	inline val rrgr get() = Vector4d(r, r, g, r)
+	inline val rrgg get() = Vector4d(r, r, g, g)
+	inline val rrgb get() = Vector4d(r, r, g, b)
+	inline val rrbr get() = Vector4d(r, r, b, r)
+	inline val rrbg get() = Vector4d(r, r, b, g)
+	inline val rrbb get() = Vector4d(r, r, b, b)
+	inline val rgrr get() = Vector4d(r, g, r, r)
+	inline val rgrg get() = Vector4d(r, g, r, g)
+	inline val rgrb get() = Vector4d(r, g, r, b)
+	inline val rggr get() = Vector4d(r, g, g, r)
+	inline val rggg get() = Vector4d(r, g, g, g)
+	inline val rggb get() = Vector4d(r, g, g, b)
+	inline val rgbr get() = Vector4d(r, g, b, r)
+	inline val rgbg get() = Vector4d(r, g, b, g)
+	inline val rgbb get() = Vector4d(r, g, b, b)
+	inline val rbrr get() = Vector4d(r, b, r, r)
+	inline val rbrg get() = Vector4d(r, b, r, g)
+	inline val rbrb get() = Vector4d(r, b, r, b)
+	inline val rbgr get() = Vector4d(r, b, g, r)
+	inline val rbgg get() = Vector4d(r, b, g, g)
+	inline val rbgb get() = Vector4d(r, b, g, b)
+	inline val rbbr get() = Vector4d(r, b, b, r)
+	inline val rbbg get() = Vector4d(r, b, b, g)
+	inline val rbbb get() = Vector4d(r, b, b, b)
+	inline val grrr get() = Vector4d(g, r, r, r)
+	inline val grrg get() = Vector4d(g, r, r, g)
+	inline val grrb get() = Vector4d(g, r, r, b)
+	inline val grgr get() = Vector4d(g, r, g, r)
+	inline val grgg get() = Vector4d(g, r, g, g)
+	inline val grgb get() = Vector4d(g, r, g, b)
+	inline val grbr get() = Vector4d(g, r, b, r)
+	inline val grbg get() = Vector4d(g, r, b, g)
+	inline val grbb get() = Vector4d(g, r, b, b)
+	inline val ggrr get() = Vector4d(g, g, r, r)
+	inline val ggrg get() = Vector4d(g, g, r, g)
+	inline val ggrb get() = Vector4d(g, g, r, b)
+	inline val gggr get() = Vector4d(g, g, g, r)
+	inline val gggg get() = Vector4d(g, g, g, g)
+	inline val gggb get() = Vector4d(g, g, g, b)
+	inline val ggbr get() = Vector4d(g, g, b, r)
+	inline val ggbg get() = Vector4d(g, g, b, g)
+	inline val ggbb get() = Vector4d(g, g, b, b)
+	inline val gbrr get() = Vector4d(g, b, r, r)
+	inline val gbrg get() = Vector4d(g, b, r, g)
+	inline val gbrb get() = Vector4d(g, b, r, b)
+	inline val gbgr get() = Vector4d(g, b, g, r)
+	inline val gbgg get() = Vector4d(g, b, g, g)
+	inline val gbgb get() = Vector4d(g, b, g, b)
+	inline val gbbr get() = Vector4d(g, b, b, r)
+	inline val gbbg get() = Vector4d(g, b, b, g)
+	inline val gbbb get() = Vector4d(g, b, b, b)
+	inline val brrr get() = Vector4d(b, r, r, r)
+	inline val brrg get() = Vector4d(b, r, r, g)
+	inline val brrb get() = Vector4d(b, r, r, b)
+	inline val brgr get() = Vector4d(b, r, g, r)
+	inline val brgg get() = Vector4d(b, r, g, g)
+	inline val brgb get() = Vector4d(b, r, g, b)
+	inline val brbr get() = Vector4d(b, r, b, r)
+	inline val brbg get() = Vector4d(b, r, b, g)
+	inline val brbb get() = Vector4d(b, r, b, b)
+	inline val bgrr get() = Vector4d(b, g, r, r)
+	inline val bgrg get() = Vector4d(b, g, r, g)
+	inline val bgrb get() = Vector4d(b, g, r, b)
+	inline val bggr get() = Vector4d(b, g, g, r)
+	inline val bggg get() = Vector4d(b, g, g, g)
+	inline val bggb get() = Vector4d(b, g, g, b)
+	inline val bgbr get() = Vector4d(b, g, b, r)
+	inline val bgbg get() = Vector4d(b, g, b, g)
+	inline val bgbb get() = Vector4d(b, g, b, b)
+	inline val bbrr get() = Vector4d(b, b, r, r)
+	inline val bbrg get() = Vector4d(b, b, r, g)
+	inline val bbrb get() = Vector4d(b, b, r, b)
+	inline val bbgr get() = Vector4d(b, b, g, r)
+	inline val bbgg get() = Vector4d(b, b, g, g)
+	inline val bbgb get() = Vector4d(b, b, g, b)
+	inline val bbbr get() = Vector4d(b, b, b, r)
+	inline val bbbg get() = Vector4d(b, b, b, g)
+	inline val bbbb get() = Vector4d(b, b, b, b)
+	inline val ss get() = Vector2d(s, s)
+	inline val st get() = Vector2d(s, t)
+	inline val sp get() = Vector2d(s, p)
+	inline val ts get() = Vector2d(t, s)
+	inline val tt get() = Vector2d(t, t)
+	inline val tp get() = Vector2d(t, p)
+	inline val ps get() = Vector2d(p, s)
+	inline val pt get() = Vector2d(p, t)
+	inline val pp get() = Vector2d(p, p)
+	inline val sss get() = Vector3d(s, s, s)
+	inline val sst get() = Vector3d(s, s, t)
+	inline val ssp get() = Vector3d(s, s, p)
+	inline val sts get() = Vector3d(s, t, s)
+	inline val stt get() = Vector3d(s, t, t)
+	inline val stp get() = Vector3d(s, t, p)
+	inline val sps get() = Vector3d(s, p, s)
+	inline val spt get() = Vector3d(s, p, t)
+	inline val spp get() = Vector3d(s, p, p)
+	inline val tss get() = Vector3d(t, s, s)
+	inline val tst get() = Vector3d(t, s, t)
+	inline val tsp get() = Vector3d(t, s, p)
+	inline val tts get() = Vector3d(t, t, s)
+	inline val ttt get() = Vector3d(t, t, t)
+	inline val ttp get() = Vector3d(t, t, p)
+	inline val tps get() = Vector3d(t, p, s)
+	inline val tpt get() = Vector3d(t, p, t)
+	inline val tpp get() = Vector3d(t, p, p)
+	inline val pss get() = Vector3d(p, s, s)
+	inline val pst get() = Vector3d(p, s, t)
+	inline val psp get() = Vector3d(p, s, p)
+	inline val pts get() = Vector3d(p, t, s)
+	inline val ptt get() = Vector3d(p, t, t)
+	inline val ptp get() = Vector3d(p, t, p)
+	inline val pps get() = Vector3d(p, p, s)
+	inline val ppt get() = Vector3d(p, p, t)
+	inline val ppp get() = Vector3d(p, p, p)
+	inline val ssss get() = Vector4d(s, s, s, s)
+	inline val ssst get() = Vector4d(s, s, s, t)
+	inline val sssp get() = Vector4d(s, s, s, p)
+	inline val ssts get() = Vector4d(s, s, t, s)
+	inline val sstt get() = Vector4d(s, s, t, t)
+	inline val sstp get() = Vector4d(s, s, t, p)
+	inline val ssps get() = Vector4d(s, s, p, s)
+	inline val sspt get() = Vector4d(s, s, p, t)
+	inline val sspp get() = Vector4d(s, s, p, p)
+	inline val stss get() = Vector4d(s, t, s, s)
+	inline val stst get() = Vector4d(s, t, s, t)
+	inline val stsp get() = Vector4d(s, t, s, p)
+	inline val stts get() = Vector4d(s, t, t, s)
+	inline val sttt get() = Vector4d(s, t, t, t)
+	inline val sttp get() = Vector4d(s, t, t, p)
+	inline val stps get() = Vector4d(s, t, p, s)
+	inline val stpt get() = Vector4d(s, t, p, t)
+	inline val stpp get() = Vector4d(s, t, p, p)
+	inline val spss get() = Vector4d(s, p, s, s)
+	inline val spst get() = Vector4d(s, p, s, t)
+	inline val spsp get() = Vector4d(s, p, s, p)
+	inline val spts get() = Vector4d(s, p, t, s)
+	inline val sptt get() = Vector4d(s, p, t, t)
+	inline val sptp get() = Vector4d(s, p, t, p)
+	inline val spps get() = Vector4d(s, p, p, s)
+	inline val sppt get() = Vector4d(s, p, p, t)
+	inline val sppp get() = Vector4d(s, p, p, p)
+	inline val tsss get() = Vector4d(t, s, s, s)
+	inline val tsst get() = Vector4d(t, s, s, t)
+	inline val tssp get() = Vector4d(t, s, s, p)
+	inline val tsts get() = Vector4d(t, s, t, s)
+	inline val tstt get() = Vector4d(t, s, t, t)
+	inline val tstp get() = Vector4d(t, s, t, p)
+	inline val tsps get() = Vector4d(t, s, p, s)
+	inline val tspt get() = Vector4d(t, s, p, t)
+	inline val tspp get() = Vector4d(t, s, p, p)
+	inline val ttss get() = Vector4d(t, t, s, s)
+	inline val ttst get() = Vector4d(t, t, s, t)
+	inline val ttsp get() = Vector4d(t, t, s, p)
+	inline val ttts get() = Vector4d(t, t, t, s)
+	inline val tttt get() = Vector4d(t, t, t, t)
+	inline val tttp get() = Vector4d(t, t, t, p)
+	inline val ttps get() = Vector4d(t, t, p, s)
+	inline val ttpt get() = Vector4d(t, t, p, t)
+	inline val ttpp get() = Vector4d(t, t, p, p)
+	inline val tpss get() = Vector4d(t, p, s, s)
+	inline val tpst get() = Vector4d(t, p, s, t)
+	inline val tpsp get() = Vector4d(t, p, s, p)
+	inline val tpts get() = Vector4d(t, p, t, s)
+	inline val tptt get() = Vector4d(t, p, t, t)
+	inline val tptp get() = Vector4d(t, p, t, p)
+	inline val tpps get() = Vector4d(t, p, p, s)
+	inline val tppt get() = Vector4d(t, p, p, t)
+	inline val tppp get() = Vector4d(t, p, p, p)
+	inline val psss get() = Vector4d(p, s, s, s)
+	inline val psst get() = Vector4d(p, s, s, t)
+	inline val pssp get() = Vector4d(p, s, s, p)
+	inline val psts get() = Vector4d(p, s, t, s)
+	inline val pstt get() = Vector4d(p, s, t, t)
+	inline val pstp get() = Vector4d(p, s, t, p)
+	inline val psps get() = Vector4d(p, s, p, s)
+	inline val pspt get() = Vector4d(p, s, p, t)
+	inline val pspp get() = Vector4d(p, s, p, p)
+	inline val ptss get() = Vector4d(p, t, s, s)
+	inline val ptst get() = Vector4d(p, t, s, t)
+	inline val ptsp get() = Vector4d(p, t, s, p)
+	inline val ptts get() = Vector4d(p, t, t, s)
+	inline val pttt get() = Vector4d(p, t, t, t)
+	inline val pttp get() = Vector4d(p, t, t, p)
+	inline val ptps get() = Vector4d(p, t, p, s)
+	inline val ptpt get() = Vector4d(p, t, p, t)
+	inline val ptpp get() = Vector4d(p, t, p, p)
+	inline val ppss get() = Vector4d(p, p, s, s)
+	inline val ppst get() = Vector4d(p, p, s, t)
+	inline val ppsp get() = Vector4d(p, p, s, p)
+	inline val ppts get() = Vector4d(p, p, t, s)
+	inline val pptt get() = Vector4d(p, p, t, t)
+	inline val pptp get() = Vector4d(p, p, t, p)
+	inline val ppps get() = Vector4d(p, p, p, s)
+	inline val pppt get() = Vector4d(p, p, p, t)
+	inline val pppp get() = Vector4d(p, p, p, p)
+
+	companion object {
+		@JvmField val ZERO = Vector3d()
+		@JvmField val POSITIVE_X = Vector3d(x = 1.0)
+		@JvmField val NEGATIVE_X = Vector3d(x = -1.0)
+		@JvmField val POSITIVE_Y = Vector3d(y = 1.0)
+		@JvmField val NEGATIVE_Y = Vector3d(y = -1.0)
+		@JvmField val POSITIVE_Z = Vector3d(z = 1.0)
+		@JvmField val NEGATIVE_Z = Vector3d(z = -1.0)
+	}
+}
+
+fun Double.div(other: Vector3d): Vector3d {
+	return Vector3d(this / other.x, this / other.y, this / other.z)
+}
+
+fun Double.times(other: Vector3d): Vector3d {
+	return Vector3d(this * other.x, this * other.y, this * other.z)
+}
+
+/**
+ * Mutable 3D Vector, representing three-dimensional coordinates as [Double]s
+ *
+ * It can be safely passed around to methods which expect immutable [Vector3d], **AND** do not store it,
+ * as mutable operations are separated from immutable ones
+ */
+open class MutableVector3d(
+	override var x: Double = 0.0,
+	override var y: Double = 0.0,
+	override var z: Double = 0.0,
+) : Vector3d(x, y, z), IMutableDoubleVector<MutableVector3d>, IMutableFractionalVector<MutableVector3d>, IMutableVector<MutableVector3d, Vector3d>, IMatrixSetterDouble {
+	constructor(input: IStruct2d, z: Double = 0.0) : this(input.component1(), input.component2(), z)
+	constructor(x: Double, input: IStruct2d) : this(x, input.component1(), input.component2())
+	constructor(input: IStruct3d) : this(input.component1(), input.component2(), input.component3())
+
+	override fun set(column: Int, row: Int, value: Double) {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		when (row) {
+			0 -> x = value
+			1 -> y = value
+			2 -> z = value
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	override var r by this::x
+	override var g by this::y
+	override var b by this::z
+
+	override var s by this::x
+	override var t by this::y
+	override var p by this::z
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as Vector3d
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+		if (z != other.z) return false
+
+		return true
+	}
+
+	override fun normalize(): Double {
+		val len = length
+
+		if (len == 0.0) {
+			return 0.0
+		}
+
+		x /= len
+		y /= len
+		z /= len
+		return len
+	}
+
+	override fun plusMut(other: Vector3d): MutableVector3d {
+		x += other.x
+		y += other.y
+		z += other.z
+		return this
+	}
+
+	override fun minusMut(other: Vector3d): MutableVector3d {
+		x -= other.x
+		y -= other.y
+		z -= other.z
+		return this
+	}
+
+	override fun timesMut(other: Vector3d): MutableVector3d {
+		x *= other.x
+		y *= other.y
+		z *= other.z
+		return this
+	}
+
+	override fun divMut(other: Vector3d): MutableVector3d {
+		x /= other.x
+		y /= other.y
+		z /= other.z
+		return this
+	}
+
+	override fun timesMut(other: Double): MutableVector3d {
+		x *= other
+		y *= other
+		z *= other
+		return this
+	}
+
+	override fun divMut(other: Double): MutableVector3d {
+		x /= other
+		y /= other
+		z /= other
+		return this
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/vector/nfloat/Vector2f.kt

@@ -0,0 +1,395 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.vector.nfloat
+
+import ru.dbotthepony.kvector.api.*
+import ru.dbotthepony.kvector.vector.ndouble.Vector2d
+import kotlin.math.absoluteValue
+
+/**
+ * 2D Vector, representing two-dimensional coordinates as [Float]s
+ */
+open class Vector2f(
+	open val x: Float = 0f,
+	open val y: Float = 0f
+) : AbstractVector<Vector2f>(), IFractionalVector<Vector2f>, IFloatVector<Vector2f>, IStruct2f, IMatrixGetterFloat {
+	final override fun component1() = x
+	final override fun component2() = y
+
+	constructor(input: IStruct2f) : this(input.component1(), input.component2())
+
+	final override fun get(column: Int, row: Int): Float {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		return when (row) {
+			0 -> x
+			1 -> y
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	final override val rows: Int = 2
+	final override val lengthSquared: Double
+		get() = x.toDouble() * x.toDouble() + y.toDouble() * y.toDouble()
+
+	final override val isFinite: Boolean
+		get() = x.isFinite() && y.isFinite()
+	final override val isNaN: Boolean
+		get() = x.isNaN() || y.isNaN()
+
+	open val r by this::x
+	open val g by this::y
+
+	open val s by this::x
+	open val t by this::y
+
+	override fun plus(other: Vector2f): Vector2f {
+		return Vector2f(
+			x + other.x,
+			y + other.y,
+		)
+	}
+
+	override fun minus(other: Vector2f): Vector2f {
+		return Vector2f(
+			x - other.x,
+			y - other.y,
+		)
+	}
+
+	override fun times(other: Vector2f): Vector2f {
+		return Vector2f(
+			x * other.x,
+			y * other.y,
+		)
+	}
+
+	override fun div(other: Vector2f): Vector2f {
+		return Vector2f(
+			x / other.x,
+			y / other.y,
+		)
+	}
+
+	override val absoluteValue: Vector2f
+		get() = Vector2f(x.absoluteValue, y.absoluteValue)
+
+	override fun coerceAtMost(maximal: Vector2f): Vector2f {
+		return Vector2f(
+			x.coerceAtMost(maximal.x),
+			y.coerceAtMost(maximal.y),
+		)
+	}
+
+	override fun coerceAtLeast(minimal: Vector2f): Vector2f {
+		return Vector2f(
+			x.coerceAtLeast(minimal.x),
+			y.coerceAtLeast(minimal.y),
+		)
+	}
+
+	override fun clamp(minimal: Vector2f, maximal: Vector2f): Vector2f {
+		return Vector2f(
+			x.coerceAtLeast(minimal.x).coerceAtMost(maximal.x),
+			y.coerceAtLeast(minimal.y).coerceAtMost(maximal.y),
+		)
+	}
+
+	override fun unaryMinus(): Vector2f {
+		return Vector2f(-x, -y)
+	}
+
+	override fun distanceSquared(other: Vector2f): Double {
+		val x = x.toDouble() - other.x.toDouble()
+		val y = y.toDouble() - other.y.toDouble()
+
+		return x * x + y * y
+	}
+
+	override val normalized: Vector2f
+		get() {
+			val len = length
+
+			if (len == 0.0) {
+				return ZERO
+			}
+
+			return Vector2f((x / len).toFloat(), (y / len).toFloat())
+		}
+
+	override fun times(other: Float): Vector2f {
+		return Vector2f(
+			x * other,
+			y * other
+		)
+	}
+
+	override fun div(other: Float): Vector2f {
+		return Vector2f(
+			x / other,
+			y / other
+		)
+	}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as Vector2f
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		var result = x.hashCode()
+		result = 31 * result + y.hashCode()
+		return result
+	}
+
+	override fun toString(): String {
+		return "[${x}f ${y}f]"
+	}
+
+	/**
+	 * Calculates vector vector * vector, returning result as [Double]
+	 */
+	fun cross(other: Vector2f): Double {
+		return x.toDouble() * other.y.toDouble() - y.toDouble() * other.x.toDouble()
+	}
+
+	/**
+	 * Calculates 2D cross product between scalar and vector
+	 *
+	 * @return new vector
+	 */
+	fun cross(other: Float): Vector2f {
+		return Vector2f(other * y, -other * x)
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector2f): Double {
+		return other.x.toDouble() * x.toDouble() + other.y.toDouble() * y.toDouble()
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector3f): Double {
+		return other.x.toDouble() * x.toDouble() + other.y.toDouble() * y.toDouble()
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector4f): Double {
+		return other.x.toDouble() * x.toDouble() + other.y.toDouble() * y.toDouble()
+	}
+
+	/**
+	 * Casts components to [Double] and returns new vector as result
+	 */
+	open fun toDoubleVector(): Vector2d {
+		return Vector2d(x.toDouble(), y.toDouble())
+	}
+
+	inline val xx get() = Vector2f(x, x)
+	inline val xy get() = Vector2f(x, y)
+	inline val yx get() = Vector2f(y, x)
+	inline val yy get() = Vector2f(y, y)
+	inline val xxx get() = Vector3f(x, x, x)
+	inline val xxy get() = Vector3f(x, x, y)
+	inline val xyx get() = Vector3f(x, y, x)
+	inline val xyy get() = Vector3f(x, y, y)
+	inline val yxx get() = Vector3f(y, x, x)
+	inline val yxy get() = Vector3f(y, x, y)
+	inline val yyx get() = Vector3f(y, y, x)
+	inline val yyy get() = Vector3f(y, y, y)
+	inline val xxxx get() = Vector4f(x, x, x, x)
+	inline val xxxy get() = Vector4f(x, x, x, y)
+	inline val xxyx get() = Vector4f(x, x, y, x)
+	inline val xxyy get() = Vector4f(x, x, y, y)
+	inline val xyxx get() = Vector4f(x, y, x, x)
+	inline val xyxy get() = Vector4f(x, y, x, y)
+	inline val xyyx get() = Vector4f(x, y, y, x)
+	inline val xyyy get() = Vector4f(x, y, y, y)
+	inline val yxxx get() = Vector4f(y, x, x, x)
+	inline val yxxy get() = Vector4f(y, x, x, y)
+	inline val yxyx get() = Vector4f(y, x, y, x)
+	inline val yxyy get() = Vector4f(y, x, y, y)
+	inline val yyxx get() = Vector4f(y, y, x, x)
+	inline val yyxy get() = Vector4f(y, y, x, y)
+	inline val yyyx get() = Vector4f(y, y, y, x)
+	inline val yyyy get() = Vector4f(y, y, y, y)
+	inline val rr get() = Vector2f(r, r)
+	inline val rg get() = Vector2f(r, g)
+	inline val gr get() = Vector2f(g, r)
+	inline val gg get() = Vector2f(g, g)
+	inline val rrr get() = Vector3f(r, r, r)
+	inline val rrg get() = Vector3f(r, r, g)
+	inline val rgr get() = Vector3f(r, g, r)
+	inline val rgg get() = Vector3f(r, g, g)
+	inline val grr get() = Vector3f(g, r, r)
+	inline val grg get() = Vector3f(g, r, g)
+	inline val ggr get() = Vector3f(g, g, r)
+	inline val ggg get() = Vector3f(g, g, g)
+	inline val rrrr get() = Vector4f(r, r, r, r)
+	inline val rrrg get() = Vector4f(r, r, r, g)
+	inline val rrgr get() = Vector4f(r, r, g, r)
+	inline val rrgg get() = Vector4f(r, r, g, g)
+	inline val rgrr get() = Vector4f(r, g, r, r)
+	inline val rgrg get() = Vector4f(r, g, r, g)
+	inline val rggr get() = Vector4f(r, g, g, r)
+	inline val rggg get() = Vector4f(r, g, g, g)
+	inline val grrr get() = Vector4f(g, r, r, r)
+	inline val grrg get() = Vector4f(g, r, r, g)
+	inline val grgr get() = Vector4f(g, r, g, r)
+	inline val grgg get() = Vector4f(g, r, g, g)
+	inline val ggrr get() = Vector4f(g, g, r, r)
+	inline val ggrg get() = Vector4f(g, g, r, g)
+	inline val gggr get() = Vector4f(g, g, g, r)
+	inline val gggg get() = Vector4f(g, g, g, g)
+	inline val ss get() = Vector2f(s, s)
+	inline val st get() = Vector2f(s, t)
+	inline val ts get() = Vector2f(t, s)
+	inline val tt get() = Vector2f(t, t)
+	inline val sss get() = Vector3f(s, s, s)
+	inline val sst get() = Vector3f(s, s, t)
+	inline val sts get() = Vector3f(s, t, s)
+	inline val stt get() = Vector3f(s, t, t)
+	inline val tss get() = Vector3f(t, s, s)
+	inline val tst get() = Vector3f(t, s, t)
+	inline val tts get() = Vector3f(t, t, s)
+	inline val ttt get() = Vector3f(t, t, t)
+	inline val ssss get() = Vector4f(s, s, s, s)
+	inline val ssst get() = Vector4f(s, s, s, t)
+	inline val ssts get() = Vector4f(s, s, t, s)
+	inline val sstt get() = Vector4f(s, s, t, t)
+	inline val stss get() = Vector4f(s, t, s, s)
+	inline val stst get() = Vector4f(s, t, s, t)
+	inline val stts get() = Vector4f(s, t, t, s)
+	inline val sttt get() = Vector4f(s, t, t, t)
+	inline val tsss get() = Vector4f(t, s, s, s)
+	inline val tsst get() = Vector4f(t, s, s, t)
+	inline val tsts get() = Vector4f(t, s, t, s)
+	inline val tstt get() = Vector4f(t, s, t, t)
+	inline val ttss get() = Vector4f(t, t, s, s)
+	inline val ttst get() = Vector4f(t, t, s, t)
+	inline val ttts get() = Vector4f(t, t, t, s)
+	inline val tttt get() = Vector4f(t, t, t, t)
+
+	companion object {
+		@JvmField val ZERO = Vector2f()
+		@JvmField val POSITIVE_X = Vector2f(x = 1f)
+		@JvmField val NEGATIVE_X = Vector2f(x = -1f)
+		@JvmField val POSITIVE_Y = Vector2f(y = 1f)
+		@JvmField val NEGATIVE_Y = Vector2f(y = -1f)
+	}
+}
+
+operator fun Float.times(other: Vector2f): Vector2f {
+	return Vector2f(this * other.x, this * other.y)
+}
+
+operator fun Float.div(other: Vector2f): Vector2f {
+	return Vector2f(this / other.x, this / other.y)
+}
+
+/**
+ * Mutable 2D Vector, representing two-dimensional coordinates as [Float]s
+ *
+ * It can be safely passed around to methods which expect immutable [Vector2f], **AND** do not store it,
+ * as mutable operations are separated from immutable ones
+ */
+open class MutableVector2f(
+	override var x: Float = 0f,
+	override var y: Float = 0f
+) : Vector2f(x, y), IMutableFloatVector<MutableVector2f>, IMutableFractionalVector<MutableVector2f>, IMutableVector<MutableVector2f, Vector2f>, IMatrixSetterFloat {
+	constructor(input: IStruct2f) : this(input.component1(), input.component2())
+
+	override fun set(column: Int, row: Int, value: Float) {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		when (row) {
+			0 -> x = value
+			1 -> y = value
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	override var r by this::x
+	override var g by this::y
+
+	override var s by this::x
+	override var t by this::y
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as MutableVector2f
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+
+		return true
+	}
+
+	override fun normalize(): Double {
+		val len = length
+
+		if (len == 0.0) {
+			return len
+		}
+
+		x = (x / len).toFloat()
+		y = (y / len).toFloat()
+
+		return len
+	}
+
+	override fun plusMut(other: Vector2f): MutableVector2f {
+		x += other.x
+		y += other.y
+		return this
+	}
+
+	override fun minusMut(other: Vector2f): MutableVector2f {
+		x -= other.x
+		y -= other.y
+		return this
+	}
+
+	override fun timesMut(other: Vector2f): MutableVector2f {
+		x *= other.x
+		y *= other.y
+		return this
+	}
+
+	override fun divMut(other: Vector2f): MutableVector2f {
+		x /= other.x
+		y /= other.y
+		return this
+	}
+
+	override fun timesMut(other: Float): MutableVector2f {
+		x *= other
+		y *= other
+		return this
+	}
+
+	override fun divMut(other: Float): MutableVector2f {
+		x /= other
+		y /= other
+		return this
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/vector/nfloat/Vector3f.kt

@@ -0,0 +1,680 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.vector.nfloat
+
+import ru.dbotthepony.kvector.api.*
+import kotlin.math.absoluteValue
+
+/**
+ * 3D Vector, representing three-dimensional coordinates as [Float]s
+ */
+open class Vector3f(
+	open val x: Float = 0f,
+	open val y: Float = 0f,
+	open val z: Float = 0f,
+) : AbstractVector<Vector3f>(), IFractionalVector<Vector3f>, IFloatVector<Vector3f>, IStruct3f, IMatrixGetterFloat {
+	final override fun component1() = x
+	final override fun component2() = y
+	final override fun component3() = z
+
+	override fun get(column: Int, row: Int): Float {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		return when (row) {
+			0 -> x
+			1 -> y
+			2 -> z
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	constructor(input: IStruct2f, z: Float = 0f) : this(input.component1(), input.component2(), z)
+	constructor(x: Float, input: IStruct2f) : this(x, input.component1(), input.component2())
+	constructor(input: IStruct3f) : this(input.component1(), input.component2(), input.component3())
+
+	final override val rows: Int = 3
+	final override val lengthSquared: Double
+		get() = x.toDouble() * x.toDouble() + y.toDouble() * y.toDouble() + z.toDouble() * z.toDouble()
+
+	final override val isFinite: Boolean
+		get() = x.isFinite() && y.isFinite() && z.isFinite()
+	final override val isNaN: Boolean
+		get() = x.isNaN() || y.isNaN() || z.isNaN()
+
+	open val r by this::x
+	open val g by this::y
+	open val b by this::z
+
+	open val s by this::x
+	open val t by this::y
+	open val p by this::z
+
+	override fun plus(other: Vector3f): Vector3f {
+		return Vector3f(
+			x + other.x,
+			y + other.y,
+			z + other.z,
+		)
+	}
+
+	override fun minus(other: Vector3f): Vector3f {
+		return Vector3f(
+			x - other.x,
+			y - other.y,
+			z - other.z,
+		)
+	}
+
+	override fun times(other: Vector3f): Vector3f {
+		return Vector3f(
+			x * other.x,
+			y * other.y,
+			z * other.z,
+		)
+	}
+
+	override fun div(other: Vector3f): Vector3f {
+		return Vector3f(
+			x / other.x,
+			y / other.y,
+			z / other.z,
+		)
+	}
+
+	override val absoluteValue: Vector3f
+		get() = Vector3f(x.absoluteValue, y.absoluteValue, z.absoluteValue)
+
+	override fun coerceAtMost(maximal: Vector3f): Vector3f {
+		return Vector3f(
+			x.coerceAtMost(maximal.x),
+			y.coerceAtMost(maximal.y),
+			z.coerceAtMost(maximal.z),
+		)
+	}
+
+	override fun coerceAtLeast(minimal: Vector3f): Vector3f {
+		return Vector3f(
+			x.coerceAtLeast(minimal.x),
+			y.coerceAtLeast(minimal.y),
+			z.coerceAtLeast(minimal.z),
+		)
+	}
+
+	override fun clamp(minimal: Vector3f, maximal: Vector3f): Vector3f {
+		return Vector3f(
+			x.coerceAtLeast(minimal.x).coerceAtMost(maximal.x),
+			y.coerceAtLeast(minimal.y).coerceAtMost(maximal.y),
+			z.coerceAtLeast(minimal.z).coerceAtMost(maximal.z),
+		)
+	}
+
+	override fun unaryMinus(): Vector3f {
+		return Vector3f(-x, -y, -z)
+	}
+
+	override fun distanceSquared(other: Vector3f): Double {
+		val x = x.toDouble() - other.x.toDouble()
+		val y = y.toDouble() - other.y.toDouble()
+		val z = z.toDouble() - other.z.toDouble()
+
+		return x * x + y * y + z * z
+	}
+
+	override val normalized: Vector3f
+		get() {
+			val len = length
+
+			if (len == 0.0) {
+				return ZERO
+			}
+
+			return Vector3f(
+				(x / len).toFloat(),
+				(y / len).toFloat(),
+				(z / len).toFloat()
+			)
+		}
+
+	override fun times(other: Float): Vector3f {
+		return Vector3f(x * other, y * other, z * other)
+	}
+
+	override fun div(other: Float): Vector3f {
+		return Vector3f(x / other, y / other, z / other)
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector4f): Double {
+		return other.x.toDouble() * x.toDouble() + other.y.toDouble() * y.toDouble() + other.z.toDouble() * z.toDouble()
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector3f): Double {
+		return other.x.toDouble() * x.toDouble() + other.y.toDouble() * y.toDouble() + other.z.toDouble() * z.toDouble()
+	}
+
+	/**
+	 * Calculates scalar vector * vector, returning result as [Double]
+	 */
+	fun dot(other: Vector2f): Double {
+		return other.x.toDouble() * x.toDouble() + other.y.toDouble() * y.toDouble()
+	}
+
+	/**
+	 * Calculates vector vector * vector, returning result as new vector
+	 */
+	fun cross(other: Vector3f): Vector3f {
+		return Vector3f(
+			y * other.z - z * other.y,
+			z * other.x - x * other.z,
+			x * other.y - y * other.x,
+		)
+	}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as Vector3f
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+		if (z != other.z) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		var result = x.hashCode()
+		result = 31 * result + y.hashCode()
+		result = 31 * result + z.hashCode()
+		return result
+	}
+
+	override fun toString(): String {
+		return "[${x}f ${y}f ${z}f]"
+	}
+
+	inline val xx get() = Vector2f(x, x)
+	inline val xy get() = Vector2f(x, y)
+	inline val xz get() = Vector2f(x, z)
+	inline val yx get() = Vector2f(y, x)
+	inline val yy get() = Vector2f(y, y)
+	inline val yz get() = Vector2f(y, z)
+	inline val zx get() = Vector2f(z, x)
+	inline val zy get() = Vector2f(z, y)
+	inline val zz get() = Vector2f(z, z)
+	inline val xxx get() = Vector3f(x, x, x)
+	inline val xxy get() = Vector3f(x, x, y)
+	inline val xxz get() = Vector3f(x, x, z)
+	inline val xyx get() = Vector3f(x, y, x)
+	inline val xyy get() = Vector3f(x, y, y)
+	inline val xyz get() = Vector3f(x, y, z)
+	inline val xzx get() = Vector3f(x, z, x)
+	inline val xzy get() = Vector3f(x, z, y)
+	inline val xzz get() = Vector3f(x, z, z)
+	inline val yxx get() = Vector3f(y, x, x)
+	inline val yxy get() = Vector3f(y, x, y)
+	inline val yxz get() = Vector3f(y, x, z)
+	inline val yyx get() = Vector3f(y, y, x)
+	inline val yyy get() = Vector3f(y, y, y)
+	inline val yyz get() = Vector3f(y, y, z)
+	inline val yzx get() = Vector3f(y, z, x)
+	inline val yzy get() = Vector3f(y, z, y)
+	inline val yzz get() = Vector3f(y, z, z)
+	inline val zxx get() = Vector3f(z, x, x)
+	inline val zxy get() = Vector3f(z, x, y)
+	inline val zxz get() = Vector3f(z, x, z)
+	inline val zyx get() = Vector3f(z, y, x)
+	inline val zyy get() = Vector3f(z, y, y)
+	inline val zyz get() = Vector3f(z, y, z)
+	inline val zzx get() = Vector3f(z, z, x)
+	inline val zzy get() = Vector3f(z, z, y)
+	inline val zzz get() = Vector3f(z, z, z)
+	inline val xxxx get() = Vector4f(x, x, x, x)
+	inline val xxxy get() = Vector4f(x, x, x, y)
+	inline val xxxz get() = Vector4f(x, x, x, z)
+	inline val xxyx get() = Vector4f(x, x, y, x)
+	inline val xxyy get() = Vector4f(x, x, y, y)
+	inline val xxyz get() = Vector4f(x, x, y, z)
+	inline val xxzx get() = Vector4f(x, x, z, x)
+	inline val xxzy get() = Vector4f(x, x, z, y)
+	inline val xxzz get() = Vector4f(x, x, z, z)
+	inline val xyxx get() = Vector4f(x, y, x, x)
+	inline val xyxy get() = Vector4f(x, y, x, y)
+	inline val xyxz get() = Vector4f(x, y, x, z)
+	inline val xyyx get() = Vector4f(x, y, y, x)
+	inline val xyyy get() = Vector4f(x, y, y, y)
+	inline val xyyz get() = Vector4f(x, y, y, z)
+	inline val xyzx get() = Vector4f(x, y, z, x)
+	inline val xyzy get() = Vector4f(x, y, z, y)
+	inline val xyzz get() = Vector4f(x, y, z, z)
+	inline val xzxx get() = Vector4f(x, z, x, x)
+	inline val xzxy get() = Vector4f(x, z, x, y)
+	inline val xzxz get() = Vector4f(x, z, x, z)
+	inline val xzyx get() = Vector4f(x, z, y, x)
+	inline val xzyy get() = Vector4f(x, z, y, y)
+	inline val xzyz get() = Vector4f(x, z, y, z)
+	inline val xzzx get() = Vector4f(x, z, z, x)
+	inline val xzzy get() = Vector4f(x, z, z, y)
+	inline val xzzz get() = Vector4f(x, z, z, z)
+	inline val yxxx get() = Vector4f(y, x, x, x)
+	inline val yxxy get() = Vector4f(y, x, x, y)
+	inline val yxxz get() = Vector4f(y, x, x, z)
+	inline val yxyx get() = Vector4f(y, x, y, x)
+	inline val yxyy get() = Vector4f(y, x, y, y)
+	inline val yxyz get() = Vector4f(y, x, y, z)
+	inline val yxzx get() = Vector4f(y, x, z, x)
+	inline val yxzy get() = Vector4f(y, x, z, y)
+	inline val yxzz get() = Vector4f(y, x, z, z)
+	inline val yyxx get() = Vector4f(y, y, x, x)
+	inline val yyxy get() = Vector4f(y, y, x, y)
+	inline val yyxz get() = Vector4f(y, y, x, z)
+	inline val yyyx get() = Vector4f(y, y, y, x)
+	inline val yyyy get() = Vector4f(y, y, y, y)
+	inline val yyyz get() = Vector4f(y, y, y, z)
+	inline val yyzx get() = Vector4f(y, y, z, x)
+	inline val yyzy get() = Vector4f(y, y, z, y)
+	inline val yyzz get() = Vector4f(y, y, z, z)
+	inline val yzxx get() = Vector4f(y, z, x, x)
+	inline val yzxy get() = Vector4f(y, z, x, y)
+	inline val yzxz get() = Vector4f(y, z, x, z)
+	inline val yzyx get() = Vector4f(y, z, y, x)
+	inline val yzyy get() = Vector4f(y, z, y, y)
+	inline val yzyz get() = Vector4f(y, z, y, z)
+	inline val yzzx get() = Vector4f(y, z, z, x)
+	inline val yzzy get() = Vector4f(y, z, z, y)
+	inline val yzzz get() = Vector4f(y, z, z, z)
+	inline val zxxx get() = Vector4f(z, x, x, x)
+	inline val zxxy get() = Vector4f(z, x, x, y)
+	inline val zxxz get() = Vector4f(z, x, x, z)
+	inline val zxyx get() = Vector4f(z, x, y, x)
+	inline val zxyy get() = Vector4f(z, x, y, y)
+	inline val zxyz get() = Vector4f(z, x, y, z)
+	inline val zxzx get() = Vector4f(z, x, z, x)
+	inline val zxzy get() = Vector4f(z, x, z, y)
+	inline val zxzz get() = Vector4f(z, x, z, z)
+	inline val zyxx get() = Vector4f(z, y, x, x)
+	inline val zyxy get() = Vector4f(z, y, x, y)
+	inline val zyxz get() = Vector4f(z, y, x, z)
+	inline val zyyx get() = Vector4f(z, y, y, x)
+	inline val zyyy get() = Vector4f(z, y, y, y)
+	inline val zyyz get() = Vector4f(z, y, y, z)
+	inline val zyzx get() = Vector4f(z, y, z, x)
+	inline val zyzy get() = Vector4f(z, y, z, y)
+	inline val zyzz get() = Vector4f(z, y, z, z)
+	inline val zzxx get() = Vector4f(z, z, x, x)
+	inline val zzxy get() = Vector4f(z, z, x, y)
+	inline val zzxz get() = Vector4f(z, z, x, z)
+	inline val zzyx get() = Vector4f(z, z, y, x)
+	inline val zzyy get() = Vector4f(z, z, y, y)
+	inline val zzyz get() = Vector4f(z, z, y, z)
+	inline val zzzx get() = Vector4f(z, z, z, x)
+	inline val zzzy get() = Vector4f(z, z, z, y)
+	inline val zzzz get() = Vector4f(z, z, z, z)
+	inline val rr get() = Vector2f(r, r)
+	inline val rg get() = Vector2f(r, g)
+	inline val rb get() = Vector2f(r, b)
+	inline val gr get() = Vector2f(g, r)
+	inline val gg get() = Vector2f(g, g)
+	inline val gb get() = Vector2f(g, b)
+	inline val br get() = Vector2f(b, r)
+	inline val bg get() = Vector2f(b, g)
+	inline val bb get() = Vector2f(b, b)
+	inline val rrr get() = Vector3f(r, r, r)
+	inline val rrg get() = Vector3f(r, r, g)
+	inline val rrb get() = Vector3f(r, r, b)
+	inline val rgr get() = Vector3f(r, g, r)
+	inline val rgg get() = Vector3f(r, g, g)
+	inline val rgb get() = Vector3f(r, g, b)
+	inline val rbr get() = Vector3f(r, b, r)
+	inline val rbg get() = Vector3f(r, b, g)
+	inline val rbb get() = Vector3f(r, b, b)
+	inline val grr get() = Vector3f(g, r, r)
+	inline val grg get() = Vector3f(g, r, g)
+	inline val grb get() = Vector3f(g, r, b)
+	inline val ggr get() = Vector3f(g, g, r)
+	inline val ggg get() = Vector3f(g, g, g)
+	inline val ggb get() = Vector3f(g, g, b)
+	inline val gbr get() = Vector3f(g, b, r)
+	inline val gbg get() = Vector3f(g, b, g)
+	inline val gbb get() = Vector3f(g, b, b)
+	inline val brr get() = Vector3f(b, r, r)
+	inline val brg get() = Vector3f(b, r, g)
+	inline val brb get() = Vector3f(b, r, b)
+	inline val bgr get() = Vector3f(b, g, r)
+	inline val bgg get() = Vector3f(b, g, g)
+	inline val bgb get() = Vector3f(b, g, b)
+	inline val bbr get() = Vector3f(b, b, r)
+	inline val bbg get() = Vector3f(b, b, g)
+	inline val bbb get() = Vector3f(b, b, b)
+	inline val rrrr get() = Vector4f(r, r, r, r)
+	inline val rrrg get() = Vector4f(r, r, r, g)
+	inline val rrrb get() = Vector4f(r, r, r, b)
+	inline val rrgr get() = Vector4f(r, r, g, r)
+	inline val rrgg get() = Vector4f(r, r, g, g)
+	inline val rrgb get() = Vector4f(r, r, g, b)
+	inline val rrbr get() = Vector4f(r, r, b, r)
+	inline val rrbg get() = Vector4f(r, r, b, g)
+	inline val rrbb get() = Vector4f(r, r, b, b)
+	inline val rgrr get() = Vector4f(r, g, r, r)
+	inline val rgrg get() = Vector4f(r, g, r, g)
+	inline val rgrb get() = Vector4f(r, g, r, b)
+	inline val rggr get() = Vector4f(r, g, g, r)
+	inline val rggg get() = Vector4f(r, g, g, g)
+	inline val rggb get() = Vector4f(r, g, g, b)
+	inline val rgbr get() = Vector4f(r, g, b, r)
+	inline val rgbg get() = Vector4f(r, g, b, g)
+	inline val rgbb get() = Vector4f(r, g, b, b)
+	inline val rbrr get() = Vector4f(r, b, r, r)
+	inline val rbrg get() = Vector4f(r, b, r, g)
+	inline val rbrb get() = Vector4f(r, b, r, b)
+	inline val rbgr get() = Vector4f(r, b, g, r)
+	inline val rbgg get() = Vector4f(r, b, g, g)
+	inline val rbgb get() = Vector4f(r, b, g, b)
+	inline val rbbr get() = Vector4f(r, b, b, r)
+	inline val rbbg get() = Vector4f(r, b, b, g)
+	inline val rbbb get() = Vector4f(r, b, b, b)
+	inline val grrr get() = Vector4f(g, r, r, r)
+	inline val grrg get() = Vector4f(g, r, r, g)
+	inline val grrb get() = Vector4f(g, r, r, b)
+	inline val grgr get() = Vector4f(g, r, g, r)
+	inline val grgg get() = Vector4f(g, r, g, g)
+	inline val grgb get() = Vector4f(g, r, g, b)
+	inline val grbr get() = Vector4f(g, r, b, r)
+	inline val grbg get() = Vector4f(g, r, b, g)
+	inline val grbb get() = Vector4f(g, r, b, b)
+	inline val ggrr get() = Vector4f(g, g, r, r)
+	inline val ggrg get() = Vector4f(g, g, r, g)
+	inline val ggrb get() = Vector4f(g, g, r, b)
+	inline val gggr get() = Vector4f(g, g, g, r)
+	inline val gggg get() = Vector4f(g, g, g, g)
+	inline val gggb get() = Vector4f(g, g, g, b)
+	inline val ggbr get() = Vector4f(g, g, b, r)
+	inline val ggbg get() = Vector4f(g, g, b, g)
+	inline val ggbb get() = Vector4f(g, g, b, b)
+	inline val gbrr get() = Vector4f(g, b, r, r)
+	inline val gbrg get() = Vector4f(g, b, r, g)
+	inline val gbrb get() = Vector4f(g, b, r, b)
+	inline val gbgr get() = Vector4f(g, b, g, r)
+	inline val gbgg get() = Vector4f(g, b, g, g)
+	inline val gbgb get() = Vector4f(g, b, g, b)
+	inline val gbbr get() = Vector4f(g, b, b, r)
+	inline val gbbg get() = Vector4f(g, b, b, g)
+	inline val gbbb get() = Vector4f(g, b, b, b)
+	inline val brrr get() = Vector4f(b, r, r, r)
+	inline val brrg get() = Vector4f(b, r, r, g)
+	inline val brrb get() = Vector4f(b, r, r, b)
+	inline val brgr get() = Vector4f(b, r, g, r)
+	inline val brgg get() = Vector4f(b, r, g, g)
+	inline val brgb get() = Vector4f(b, r, g, b)
+	inline val brbr get() = Vector4f(b, r, b, r)
+	inline val brbg get() = Vector4f(b, r, b, g)
+	inline val brbb get() = Vector4f(b, r, b, b)
+	inline val bgrr get() = Vector4f(b, g, r, r)
+	inline val bgrg get() = Vector4f(b, g, r, g)
+	inline val bgrb get() = Vector4f(b, g, r, b)
+	inline val bggr get() = Vector4f(b, g, g, r)
+	inline val bggg get() = Vector4f(b, g, g, g)
+	inline val bggb get() = Vector4f(b, g, g, b)
+	inline val bgbr get() = Vector4f(b, g, b, r)
+	inline val bgbg get() = Vector4f(b, g, b, g)
+	inline val bgbb get() = Vector4f(b, g, b, b)
+	inline val bbrr get() = Vector4f(b, b, r, r)
+	inline val bbrg get() = Vector4f(b, b, r, g)
+	inline val bbrb get() = Vector4f(b, b, r, b)
+	inline val bbgr get() = Vector4f(b, b, g, r)
+	inline val bbgg get() = Vector4f(b, b, g, g)
+	inline val bbgb get() = Vector4f(b, b, g, b)
+	inline val bbbr get() = Vector4f(b, b, b, r)
+	inline val bbbg get() = Vector4f(b, b, b, g)
+	inline val bbbb get() = Vector4f(b, b, b, b)
+	inline val ss get() = Vector2f(s, s)
+	inline val st get() = Vector2f(s, t)
+	inline val sp get() = Vector2f(s, p)
+	inline val ts get() = Vector2f(t, s)
+	inline val tt get() = Vector2f(t, t)
+	inline val tp get() = Vector2f(t, p)
+	inline val ps get() = Vector2f(p, s)
+	inline val pt get() = Vector2f(p, t)
+	inline val pp get() = Vector2f(p, p)
+	inline val sss get() = Vector3f(s, s, s)
+	inline val sst get() = Vector3f(s, s, t)
+	inline val ssp get() = Vector3f(s, s, p)
+	inline val sts get() = Vector3f(s, t, s)
+	inline val stt get() = Vector3f(s, t, t)
+	inline val stp get() = Vector3f(s, t, p)
+	inline val sps get() = Vector3f(s, p, s)
+	inline val spt get() = Vector3f(s, p, t)
+	inline val spp get() = Vector3f(s, p, p)
+	inline val tss get() = Vector3f(t, s, s)
+	inline val tst get() = Vector3f(t, s, t)
+	inline val tsp get() = Vector3f(t, s, p)
+	inline val tts get() = Vector3f(t, t, s)
+	inline val ttt get() = Vector3f(t, t, t)
+	inline val ttp get() = Vector3f(t, t, p)
+	inline val tps get() = Vector3f(t, p, s)
+	inline val tpt get() = Vector3f(t, p, t)
+	inline val tpp get() = Vector3f(t, p, p)
+	inline val pss get() = Vector3f(p, s, s)
+	inline val pst get() = Vector3f(p, s, t)
+	inline val psp get() = Vector3f(p, s, p)
+	inline val pts get() = Vector3f(p, t, s)
+	inline val ptt get() = Vector3f(p, t, t)
+	inline val ptp get() = Vector3f(p, t, p)
+	inline val pps get() = Vector3f(p, p, s)
+	inline val ppt get() = Vector3f(p, p, t)
+	inline val ppp get() = Vector3f(p, p, p)
+	inline val ssss get() = Vector4f(s, s, s, s)
+	inline val ssst get() = Vector4f(s, s, s, t)
+	inline val sssp get() = Vector4f(s, s, s, p)
+	inline val ssts get() = Vector4f(s, s, t, s)
+	inline val sstt get() = Vector4f(s, s, t, t)
+	inline val sstp get() = Vector4f(s, s, t, p)
+	inline val ssps get() = Vector4f(s, s, p, s)
+	inline val sspt get() = Vector4f(s, s, p, t)
+	inline val sspp get() = Vector4f(s, s, p, p)
+	inline val stss get() = Vector4f(s, t, s, s)
+	inline val stst get() = Vector4f(s, t, s, t)
+	inline val stsp get() = Vector4f(s, t, s, p)
+	inline val stts get() = Vector4f(s, t, t, s)
+	inline val sttt get() = Vector4f(s, t, t, t)
+	inline val sttp get() = Vector4f(s, t, t, p)
+	inline val stps get() = Vector4f(s, t, p, s)
+	inline val stpt get() = Vector4f(s, t, p, t)
+	inline val stpp get() = Vector4f(s, t, p, p)
+	inline val spss get() = Vector4f(s, p, s, s)
+	inline val spst get() = Vector4f(s, p, s, t)
+	inline val spsp get() = Vector4f(s, p, s, p)
+	inline val spts get() = Vector4f(s, p, t, s)
+	inline val sptt get() = Vector4f(s, p, t, t)
+	inline val sptp get() = Vector4f(s, p, t, p)
+	inline val spps get() = Vector4f(s, p, p, s)
+	inline val sppt get() = Vector4f(s, p, p, t)
+	inline val sppp get() = Vector4f(s, p, p, p)
+	inline val tsss get() = Vector4f(t, s, s, s)
+	inline val tsst get() = Vector4f(t, s, s, t)
+	inline val tssp get() = Vector4f(t, s, s, p)
+	inline val tsts get() = Vector4f(t, s, t, s)
+	inline val tstt get() = Vector4f(t, s, t, t)
+	inline val tstp get() = Vector4f(t, s, t, p)
+	inline val tsps get() = Vector4f(t, s, p, s)
+	inline val tspt get() = Vector4f(t, s, p, t)
+	inline val tspp get() = Vector4f(t, s, p, p)
+	inline val ttss get() = Vector4f(t, t, s, s)
+	inline val ttst get() = Vector4f(t, t, s, t)
+	inline val ttsp get() = Vector4f(t, t, s, p)
+	inline val ttts get() = Vector4f(t, t, t, s)
+	inline val tttt get() = Vector4f(t, t, t, t)
+	inline val tttp get() = Vector4f(t, t, t, p)
+	inline val ttps get() = Vector4f(t, t, p, s)
+	inline val ttpt get() = Vector4f(t, t, p, t)
+	inline val ttpp get() = Vector4f(t, t, p, p)
+	inline val tpss get() = Vector4f(t, p, s, s)
+	inline val tpst get() = Vector4f(t, p, s, t)
+	inline val tpsp get() = Vector4f(t, p, s, p)
+	inline val tpts get() = Vector4f(t, p, t, s)
+	inline val tptt get() = Vector4f(t, p, t, t)
+	inline val tptp get() = Vector4f(t, p, t, p)
+	inline val tpps get() = Vector4f(t, p, p, s)
+	inline val tppt get() = Vector4f(t, p, p, t)
+	inline val tppp get() = Vector4f(t, p, p, p)
+	inline val psss get() = Vector4f(p, s, s, s)
+	inline val psst get() = Vector4f(p, s, s, t)
+	inline val pssp get() = Vector4f(p, s, s, p)
+	inline val psts get() = Vector4f(p, s, t, s)
+	inline val pstt get() = Vector4f(p, s, t, t)
+	inline val pstp get() = Vector4f(p, s, t, p)
+	inline val psps get() = Vector4f(p, s, p, s)
+	inline val pspt get() = Vector4f(p, s, p, t)
+	inline val pspp get() = Vector4f(p, s, p, p)
+	inline val ptss get() = Vector4f(p, t, s, s)
+	inline val ptst get() = Vector4f(p, t, s, t)
+	inline val ptsp get() = Vector4f(p, t, s, p)
+	inline val ptts get() = Vector4f(p, t, t, s)
+	inline val pttt get() = Vector4f(p, t, t, t)
+	inline val pttp get() = Vector4f(p, t, t, p)
+	inline val ptps get() = Vector4f(p, t, p, s)
+	inline val ptpt get() = Vector4f(p, t, p, t)
+	inline val ptpp get() = Vector4f(p, t, p, p)
+	inline val ppss get() = Vector4f(p, p, s, s)
+	inline val ppst get() = Vector4f(p, p, s, t)
+	inline val ppsp get() = Vector4f(p, p, s, p)
+	inline val ppts get() = Vector4f(p, p, t, s)
+	inline val pptt get() = Vector4f(p, p, t, t)
+	inline val pptp get() = Vector4f(p, p, t, p)
+	inline val ppps get() = Vector4f(p, p, p, s)
+	inline val pppt get() = Vector4f(p, p, p, t)
+	inline val pppp get() = Vector4f(p, p, p, p)
+
+	companion object {
+		@JvmField val ZERO = Vector3f()
+		@JvmField val POSITIVE_X = Vector3f(x = 1f)
+		@JvmField val NEGATIVE_X = Vector3f(x = -1f)
+		@JvmField val POSITIVE_Y = Vector3f(y = 1f)
+		@JvmField val NEGATIVE_Y = Vector3f(y = -1f)
+		@JvmField val POSITIVE_Z = Vector3f(z = 1f)
+		@JvmField val NEGATIVE_Z = Vector3f(z = -1f)
+	}
+}
+
+operator fun Float.times(other: Vector3f): Vector3f {
+	return Vector3f(this * other.x, this * other.y, this * other.z)
+}
+
+operator fun Float.div(other: Vector3f): Vector3f {
+	return Vector3f(this / other.x, this / other.y, this / other.z)
+}
+
+/**
+ * Mutable 3D Vector, representing three-dimensional coordinates as [Float]s
+ *
+ * It can be safely passed around to methods which expect immutable [Vector3f], **AND** do not store it,
+ * as mutable operations are separated from immutable ones
+ */
+open class MutableVector3f(
+	override var x: Float = 0f,
+	override var y: Float = 0f,
+	override var z: Float = 0f,
+) : Vector3f(x, y), IMutableFloatVector<MutableVector3f>, IMutableFractionalVector<MutableVector3f>, IMutableVector<MutableVector3f, Vector3f>, IMatrixSetterFloat {
+	constructor(input: IStruct2f, z: Float = 0f) : this(input.component1(), input.component2(), z)
+	constructor(x: Float, input: IStruct2f) : this(x, input.component1(), input.component2())
+	constructor(input: IStruct3f) : this(input.component1(), input.component2(), input.component3())
+
+	override fun set(column: Int, row: Int, value: Float) {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		when (row) {
+			0 -> x = value
+			1 -> y = value
+			2 -> z = value
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	override var r by this::x
+	override var g by this::y
+	override var b by this::z
+
+	override var s by this::x
+	override var t by this::y
+	override var p by this::z
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as MutableVector3f
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+		if (z != other.z) return false
+
+		return true
+	}
+
+	override fun normalize(): Double {
+		val len = length
+
+		if (len == 0.0) {
+			return 0.0
+		}
+
+		x = (x / len).toFloat()
+		y = (y / len).toFloat()
+		z = (z / len).toFloat()
+
+		return len
+	}
+
+	override fun plusMut(other: Vector3f): MutableVector3f {
+		x += other.x
+		y += other.y
+		z += other.z
+		return this
+	}
+
+	override fun minusMut(other: Vector3f): MutableVector3f {
+		x -= other.x
+		y -= other.y
+		z -= other.z
+		return this
+	}
+
+	override fun timesMut(other: Vector3f): MutableVector3f {
+		x *= other.x
+		y *= other.y
+		z *= other.z
+		return this
+	}
+
+	override fun divMut(other: Vector3f): MutableVector3f {
+		x /= other.x
+		y /= other.y
+		z /= other.z
+		return this
+	}
+
+	override fun timesMut(other: Float): MutableVector3f {
+		x *= other
+		y *= other
+		z *= other
+		return this
+	}
+
+	override fun divMut(other: Float): MutableVector3f {
+		x /= other
+		y /= other
+		z /= other
+		return this
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/vector/nint/Vector2i.kt

@@ -0,0 +1,331 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.vector.nint
+
+import ru.dbotthepony.kvector.api.*
+import kotlin.math.absoluteValue
+
+/**
+ * 2D Vector, representing two-dimensional coordinates as [Int]s
+ */
+open class Vector2i(
+	open val x: Int = 0,
+	open val y: Int = 0,
+) : AbstractVector<Vector2i>(), IWholeVector<Vector2i>, IIntVector<Vector2i>, IStruct2i, IMatrixGetterInt {
+	constructor(input: IStruct2i) : this(input.component1(), input.component2())
+
+	final override fun get(column: Int, row: Int): Int {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		return when (row) {
+			0 -> x
+			1 -> y
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	final override val rows: Int = 2
+
+	final override fun component1() = x
+	final override fun component2() = y
+
+	open val r by this::x
+	open val g by this::y
+
+	open val s by this::x
+	open val t by this::y
+
+	final override val lengthSquared: Double
+		get() = (x.toLong() * x.toLong() + y.toLong() * y.toLong()).toDouble()
+	final override val isFinite: Boolean = true
+	final override val isNaN: Boolean = false
+
+	override fun plus(other: Vector2i): Vector2i {
+		return Vector2i(
+			x + other.x,
+			y + other.y,
+		)
+	}
+
+	override fun minus(other: Vector2i): Vector2i {
+		return Vector2i(
+			x - other.x,
+			y - other.y,
+		)
+	}
+
+	override fun times(other: Vector2i): Vector2i {
+		return Vector2i(
+			x * other.x,
+			y * other.y,
+		)
+	}
+
+	override fun div(other: Vector2i): Vector2i {
+		return Vector2i(
+			x / other.x,
+			y / other.y,
+		)
+	}
+
+	override val absoluteValue: Vector2i
+		get() = Vector2i(x.absoluteValue, y.absoluteValue)
+
+	override fun coerceAtMost(maximal: Vector2i): Vector2i {
+		return Vector2i(
+			x.coerceAtMost(maximal.x),
+			y.coerceAtMost(maximal.y),
+		)
+	}
+
+	override fun coerceAtLeast(minimal: Vector2i): Vector2i {
+		return Vector2i(
+			x.coerceAtLeast(minimal.x),
+			y.coerceAtLeast(minimal.y),
+		)
+	}
+
+	override fun clamp(minimal: Vector2i, maximal: Vector2i): Vector2i {
+		return Vector2i(
+			x.coerceAtLeast(minimal.x).coerceAtMost(maximal.x),
+			y.coerceAtLeast(minimal.y).coerceAtMost(maximal.y),
+		)
+	}
+
+	override fun unaryMinus(): Vector2i {
+		return Vector2i(-x, -y)
+	}
+
+	override fun distanceSquared(other: Vector2i): Double {
+		val x = x.toDouble() - other.x.toDouble()
+		val y = y.toDouble() - other.y.toDouble()
+
+		return x * x + y * y
+	}
+
+	override fun wholeDistanceSquared(other: Vector2i): Long {
+		val x = x.toLong() - other.x.toLong()
+		val y = y.toLong() - other.y.toLong()
+
+		return x * x + y * y
+	}
+
+	override fun times(other: Int): Vector2i {
+		return Vector2i(
+			x * other,
+			y * other,
+		)
+	}
+
+	override fun div(other: Int): Vector2i {
+		return Vector2i(
+			x / other,
+			y / other,
+		)
+	}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as Vector2i
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		var result = x
+		result = 31 * result + y
+		return result
+	}
+
+	override fun toString(): String {
+		return "[${x}i ${y}i]"
+	}
+
+	inline val xx get() = Vector2i(x, x)
+	inline val xy get() = Vector2i(x, y)
+	inline val yx get() = Vector2i(y, x)
+	inline val yy get() = Vector2i(y, y)
+	inline val xxx get() = Vector3i(x, x, x)
+	inline val xxy get() = Vector3i(x, x, y)
+	inline val xyx get() = Vector3i(x, y, x)
+	inline val xyy get() = Vector3i(x, y, y)
+	inline val yxx get() = Vector3i(y, x, x)
+	inline val yxy get() = Vector3i(y, x, y)
+	inline val yyx get() = Vector3i(y, y, x)
+	inline val yyy get() = Vector3i(y, y, y)
+	inline val xxxx get() = Vector4i(x, x, x, x)
+	inline val xxxy get() = Vector4i(x, x, x, y)
+	inline val xxyx get() = Vector4i(x, x, y, x)
+	inline val xxyy get() = Vector4i(x, x, y, y)
+	inline val xyxx get() = Vector4i(x, y, x, x)
+	inline val xyxy get() = Vector4i(x, y, x, y)
+	inline val xyyx get() = Vector4i(x, y, y, x)
+	inline val xyyy get() = Vector4i(x, y, y, y)
+	inline val yxxx get() = Vector4i(y, x, x, x)
+	inline val yxxy get() = Vector4i(y, x, x, y)
+	inline val yxyx get() = Vector4i(y, x, y, x)
+	inline val yxyy get() = Vector4i(y, x, y, y)
+	inline val yyxx get() = Vector4i(y, y, x, x)
+	inline val yyxy get() = Vector4i(y, y, x, y)
+	inline val yyyx get() = Vector4i(y, y, y, x)
+	inline val yyyy get() = Vector4i(y, y, y, y)
+	inline val rr get() = Vector2i(r, r)
+	inline val rg get() = Vector2i(r, g)
+	inline val gr get() = Vector2i(g, r)
+	inline val gg get() = Vector2i(g, g)
+	inline val rrr get() = Vector3i(r, r, r)
+	inline val rrg get() = Vector3i(r, r, g)
+	inline val rgr get() = Vector3i(r, g, r)
+	inline val rgg get() = Vector3i(r, g, g)
+	inline val grr get() = Vector3i(g, r, r)
+	inline val grg get() = Vector3i(g, r, g)
+	inline val ggr get() = Vector3i(g, g, r)
+	inline val ggg get() = Vector3i(g, g, g)
+	inline val rrrr get() = Vector4i(r, r, r, r)
+	inline val rrrg get() = Vector4i(r, r, r, g)
+	inline val rrgr get() = Vector4i(r, r, g, r)
+	inline val rrgg get() = Vector4i(r, r, g, g)
+	inline val rgrr get() = Vector4i(r, g, r, r)
+	inline val rgrg get() = Vector4i(r, g, r, g)
+	inline val rggr get() = Vector4i(r, g, g, r)
+	inline val rggg get() = Vector4i(r, g, g, g)
+	inline val grrr get() = Vector4i(g, r, r, r)
+	inline val grrg get() = Vector4i(g, r, r, g)
+	inline val grgr get() = Vector4i(g, r, g, r)
+	inline val grgg get() = Vector4i(g, r, g, g)
+	inline val ggrr get() = Vector4i(g, g, r, r)
+	inline val ggrg get() = Vector4i(g, g, r, g)
+	inline val gggr get() = Vector4i(g, g, g, r)
+	inline val gggg get() = Vector4i(g, g, g, g)
+	inline val ss get() = Vector2i(s, s)
+	inline val st get() = Vector2i(s, t)
+	inline val ts get() = Vector2i(t, s)
+	inline val tt get() = Vector2i(t, t)
+	inline val sss get() = Vector3i(s, s, s)
+	inline val sst get() = Vector3i(s, s, t)
+	inline val sts get() = Vector3i(s, t, s)
+	inline val stt get() = Vector3i(s, t, t)
+	inline val tss get() = Vector3i(t, s, s)
+	inline val tst get() = Vector3i(t, s, t)
+	inline val tts get() = Vector3i(t, t, s)
+	inline val ttt get() = Vector3i(t, t, t)
+	inline val ssss get() = Vector4i(s, s, s, s)
+	inline val ssst get() = Vector4i(s, s, s, t)
+	inline val ssts get() = Vector4i(s, s, t, s)
+	inline val sstt get() = Vector4i(s, s, t, t)
+	inline val stss get() = Vector4i(s, t, s, s)
+	inline val stst get() = Vector4i(s, t, s, t)
+	inline val stts get() = Vector4i(s, t, t, s)
+	inline val sttt get() = Vector4i(s, t, t, t)
+	inline val tsss get() = Vector4i(t, s, s, s)
+	inline val tsst get() = Vector4i(t, s, s, t)
+	inline val tsts get() = Vector4i(t, s, t, s)
+	inline val tstt get() = Vector4i(t, s, t, t)
+	inline val ttss get() = Vector4i(t, t, s, s)
+	inline val ttst get() = Vector4i(t, t, s, t)
+	inline val ttts get() = Vector4i(t, t, t, s)
+	inline val tttt get() = Vector4i(t, t, t, t)
+
+	companion object {
+		@JvmField val ZERO = Vector2i()
+		@JvmField val POSITIVE_X = Vector2i(x = 1)
+		@JvmField val NEGATIVE_X = Vector2i(x = -1)
+		@JvmField val POSITIVE_Y = Vector2i(y = 1)
+		@JvmField val NEGATIVE_Y = Vector2i(y = -1)
+	}
+}
+
+operator fun Int.times(other: Vector2i): Vector2i {
+	return Vector2i(this * other.x, this * other.y)
+}
+
+operator fun Int.div(other: Vector2i): Vector2i {
+	return Vector2i(this / other.x, this / other.y)
+}
+
+/**
+ * Mutable 2D Vector, representing two-dimensional coordinates as [Int]s
+ *
+ * It can be safely passed around to methods which expect immutable [Vector2i], **AND** do not store it,
+ * as mutable operations are separated from immutable ones
+ */
+open class MutableVector2i(
+	override var x: Int = 0,
+	override var y: Int = 0,
+) : Vector2i(x, y), IMutableIntVector<MutableVector2i>, IMutableWholeVector<MutableVector2i>, IMutableVector<MutableVector2i, Vector2i>, IMatrixSetterInt {
+	constructor(input: IStruct2i) : this(input.component1(), input.component2())
+
+	override fun set(column: Int, row: Int, value: Int) {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		when (row) {
+			0 -> x = value
+			1 -> y = value
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	override var r by this::x
+	override var g by this::y
+
+	override var s by this::x
+	override var t by this::y
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as MutableVector2i
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+
+		return true
+	}
+
+	override fun plusMut(other: Vector2i): MutableVector2i {
+		x += other.x
+		y += other.y
+		return this
+	}
+
+	override fun minusMut(other: Vector2i): MutableVector2i {
+		x -= other.x
+		y -= other.y
+		return this
+	}
+
+	override fun timesMut(other: Vector2i): MutableVector2i {
+		x *= other.x
+		y *= other.y
+		return this
+	}
+
+	override fun divMut(other: Vector2i): MutableVector2i {
+		x /= other.x
+		y /= other.y
+		return this
+	}
+
+	override fun timesMut(other: Int): MutableVector2i {
+		x *= other
+		y *= other
+		return this
+	}
+
+	override fun divMut(other: Int): MutableVector2i {
+		x /= other
+		y /= other
+		return this
+	}
+}

src/kvector/kotlin/ru/dbotthepony/kvector/vector/nint/Vector3i.kt

@@ -0,0 +1,632 @@
+
+@file:Suppress("nothing_to_inline", "unused")
+
+package ru.dbotthepony.kvector.vector.nint
+
+import ru.dbotthepony.kvector.api.*
+import kotlin.math.absoluteValue
+
+/**
+ * 3D Vector, representing three-dimensional coordinates as [Int]s
+ */
+open class Vector3i(
+	open val x: Int = 0,
+	open val y: Int = 0,
+	open val z: Int = 0,
+) : AbstractVector<Vector3i>(), IWholeVector<Vector3i>, IIntVector<Vector3i>, IStruct3i, IMatrixGetterInt {
+	constructor(input: IStruct2i, z: Int = 0) : this(input.component1(), input.component2(), z)
+	constructor(x: Int, input: IStruct2i) : this(x, input.component1(), input.component2())
+	constructor(input: IStruct3i) : this(input.component1(), input.component2(), input.component3())
+
+	override fun get(column: Int, row: Int): Int {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		return when (row) {
+			0 -> x
+			1 -> y
+			2 -> z
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	final override val rows: Int = 3
+
+	final override fun component1() = x
+	final override fun component2() = y
+	final override fun component3() = z
+
+	open val r by this::x
+	open val g by this::y
+	open val b by this::z
+
+	open val s by this::x
+	open val t by this::y
+	open val p by this::z
+
+	final override val lengthSquared: Double
+		get() = (x.toLong() * x.toLong() + y.toLong() * y.toLong() + z.toLong() * z.toLong()).toDouble()
+	final override val isFinite: Boolean = true
+	final override val isNaN: Boolean = false
+
+	override fun plus(other: Vector3i): Vector3i {
+		return Vector3i(
+			x + other.x,
+			y + other.y,
+			z + other.z,
+		)
+	}
+
+	override fun minus(other: Vector3i): Vector3i {
+		return Vector3i(
+			x - other.x,
+			y - other.y,
+			z - other.z,
+		)
+	}
+
+	override fun times(other: Vector3i): Vector3i {
+		return Vector3i(
+			x * other.x,
+			y * other.y,
+			z * other.z,
+		)
+	}
+
+	override fun div(other: Vector3i): Vector3i {
+		return Vector3i(
+			x / other.x,
+			y / other.y,
+			z / other.z,
+		)
+	}
+
+	override val absoluteValue: Vector3i
+		get() = Vector3i(x.absoluteValue, y.absoluteValue, z.absoluteValue)
+
+	override fun coerceAtMost(maximal: Vector3i): Vector3i {
+		return Vector3i(
+			x.coerceAtMost(maximal.x),
+			y.coerceAtMost(maximal.y),
+			z.coerceAtMost(maximal.z),
+		)
+	}
+
+	override fun coerceAtLeast(minimal: Vector3i): Vector3i {
+		return Vector3i(
+			x.coerceAtLeast(minimal.x),
+			y.coerceAtLeast(minimal.y),
+			z.coerceAtLeast(minimal.z),
+		)
+	}
+
+	override fun clamp(minimal: Vector3i, maximal: Vector3i): Vector3i {
+		return Vector3i(
+			x.coerceAtLeast(minimal.x).coerceAtMost(maximal.x),
+			y.coerceAtLeast(minimal.y).coerceAtMost(maximal.y),
+			z.coerceAtLeast(minimal.z).coerceAtMost(maximal.z),
+		)
+	}
+
+	override fun unaryMinus(): Vector3i {
+		return Vector3i(-x, -y, -z)
+	}
+
+	override fun distanceSquared(other: Vector3i): Double {
+		val x = x.toDouble() - other.x.toDouble()
+		val y = y.toDouble() - other.y.toDouble()
+		val z = z.toDouble() - other.z.toDouble()
+
+		return x * x + y * y + z * z
+	}
+
+	override fun wholeDistanceSquared(other: Vector3i): Long {
+		val x = x.toLong() - other.x.toLong()
+		val y = y.toLong() - other.y.toLong()
+		val z = z.toLong() - other.z.toLong()
+
+		return x * x + y * y + z * z
+	}
+
+	override fun times(other: Int): Vector3i {
+		return Vector3i(
+			x * other,
+			y * other,
+			z * other,
+		)
+	}
+
+	override fun div(other: Int): Vector3i {
+		return Vector3i(
+			x / other,
+			y / other,
+			z / other,
+		)
+	}
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as Vector3i
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+		if (z != other.z) return false
+
+		return true
+	}
+
+	override fun hashCode(): Int {
+		var result = x
+		result = 31 * result + y
+		result = 31 * result + z
+		return result
+	}
+
+	override fun toString(): String {
+		return "[${x}i ${y}i ${z}i]"
+	}
+	inline val xx get() = Vector2i(x, x)
+	inline val xy get() = Vector2i(x, y)
+	inline val xz get() = Vector2i(x, z)
+	inline val yx get() = Vector2i(y, x)
+	inline val yy get() = Vector2i(y, y)
+	inline val yz get() = Vector2i(y, z)
+	inline val zx get() = Vector2i(z, x)
+	inline val zy get() = Vector2i(z, y)
+	inline val zz get() = Vector2i(z, z)
+	inline val xxx get() = Vector3i(x, x, x)
+	inline val xxy get() = Vector3i(x, x, y)
+	inline val xxz get() = Vector3i(x, x, z)
+	inline val xyx get() = Vector3i(x, y, x)
+	inline val xyy get() = Vector3i(x, y, y)
+	inline val xyz get() = Vector3i(x, y, z)
+	inline val xzx get() = Vector3i(x, z, x)
+	inline val xzy get() = Vector3i(x, z, y)
+	inline val xzz get() = Vector3i(x, z, z)
+	inline val yxx get() = Vector3i(y, x, x)
+	inline val yxy get() = Vector3i(y, x, y)
+	inline val yxz get() = Vector3i(y, x, z)
+	inline val yyx get() = Vector3i(y, y, x)
+	inline val yyy get() = Vector3i(y, y, y)
+	inline val yyz get() = Vector3i(y, y, z)
+	inline val yzx get() = Vector3i(y, z, x)
+	inline val yzy get() = Vector3i(y, z, y)
+	inline val yzz get() = Vector3i(y, z, z)
+	inline val zxx get() = Vector3i(z, x, x)
+	inline val zxy get() = Vector3i(z, x, y)
+	inline val zxz get() = Vector3i(z, x, z)
+	inline val zyx get() = Vector3i(z, y, x)
+	inline val zyy get() = Vector3i(z, y, y)
+	inline val zyz get() = Vector3i(z, y, z)
+	inline val zzx get() = Vector3i(z, z, x)
+	inline val zzy get() = Vector3i(z, z, y)
+	inline val zzz get() = Vector3i(z, z, z)
+	inline val xxxx get() = Vector4i(x, x, x, x)
+	inline val xxxy get() = Vector4i(x, x, x, y)
+	inline val xxxz get() = Vector4i(x, x, x, z)
+	inline val xxyx get() = Vector4i(x, x, y, x)
+	inline val xxyy get() = Vector4i(x, x, y, y)
+	inline val xxyz get() = Vector4i(x, x, y, z)
+	inline val xxzx get() = Vector4i(x, x, z, x)
+	inline val xxzy get() = Vector4i(x, x, z, y)
+	inline val xxzz get() = Vector4i(x, x, z, z)
+	inline val xyxx get() = Vector4i(x, y, x, x)
+	inline val xyxy get() = Vector4i(x, y, x, y)
+	inline val xyxz get() = Vector4i(x, y, x, z)
+	inline val xyyx get() = Vector4i(x, y, y, x)
+	inline val xyyy get() = Vector4i(x, y, y, y)
+	inline val xyyz get() = Vector4i(x, y, y, z)
+	inline val xyzx get() = Vector4i(x, y, z, x)
+	inline val xyzy get() = Vector4i(x, y, z, y)
+	inline val xyzz get() = Vector4i(x, y, z, z)
+	inline val xzxx get() = Vector4i(x, z, x, x)
+	inline val xzxy get() = Vector4i(x, z, x, y)
+	inline val xzxz get() = Vector4i(x, z, x, z)
+	inline val xzyx get() = Vector4i(x, z, y, x)
+	inline val xzyy get() = Vector4i(x, z, y, y)
+	inline val xzyz get() = Vector4i(x, z, y, z)
+	inline val xzzx get() = Vector4i(x, z, z, x)
+	inline val xzzy get() = Vector4i(x, z, z, y)
+	inline val xzzz get() = Vector4i(x, z, z, z)
+	inline val yxxx get() = Vector4i(y, x, x, x)
+	inline val yxxy get() = Vector4i(y, x, x, y)
+	inline val yxxz get() = Vector4i(y, x, x, z)
+	inline val yxyx get() = Vector4i(y, x, y, x)
+	inline val yxyy get() = Vector4i(y, x, y, y)
+	inline val yxyz get() = Vector4i(y, x, y, z)
+	inline val yxzx get() = Vector4i(y, x, z, x)
+	inline val yxzy get() = Vector4i(y, x, z, y)
+	inline val yxzz get() = Vector4i(y, x, z, z)
+	inline val yyxx get() = Vector4i(y, y, x, x)
+	inline val yyxy get() = Vector4i(y, y, x, y)
+	inline val yyxz get() = Vector4i(y, y, x, z)
+	inline val yyyx get() = Vector4i(y, y, y, x)
+	inline val yyyy get() = Vector4i(y, y, y, y)
+	inline val yyyz get() = Vector4i(y, y, y, z)
+	inline val yyzx get() = Vector4i(y, y, z, x)
+	inline val yyzy get() = Vector4i(y, y, z, y)
+	inline val yyzz get() = Vector4i(y, y, z, z)
+	inline val yzxx get() = Vector4i(y, z, x, x)
+	inline val yzxy get() = Vector4i(y, z, x, y)
+	inline val yzxz get() = Vector4i(y, z, x, z)
+	inline val yzyx get() = Vector4i(y, z, y, x)
+	inline val yzyy get() = Vector4i(y, z, y, y)
+	inline val yzyz get() = Vector4i(y, z, y, z)
+	inline val yzzx get() = Vector4i(y, z, z, x)
+	inline val yzzy get() = Vector4i(y, z, z, y)
+	inline val yzzz get() = Vector4i(y, z, z, z)
+	inline val zxxx get() = Vector4i(z, x, x, x)
+	inline val zxxy get() = Vector4i(z, x, x, y)
+	inline val zxxz get() = Vector4i(z, x, x, z)
+	inline val zxyx get() = Vector4i(z, x, y, x)
+	inline val zxyy get() = Vector4i(z, x, y, y)
+	inline val zxyz get() = Vector4i(z, x, y, z)
+	inline val zxzx get() = Vector4i(z, x, z, x)
+	inline val zxzy get() = Vector4i(z, x, z, y)
+	inline val zxzz get() = Vector4i(z, x, z, z)
+	inline val zyxx get() = Vector4i(z, y, x, x)
+	inline val zyxy get() = Vector4i(z, y, x, y)
+	inline val zyxz get() = Vector4i(z, y, x, z)
+	inline val zyyx get() = Vector4i(z, y, y, x)
+	inline val zyyy get() = Vector4i(z, y, y, y)
+	inline val zyyz get() = Vector4i(z, y, y, z)
+	inline val zyzx get() = Vector4i(z, y, z, x)
+	inline val zyzy get() = Vector4i(z, y, z, y)
+	inline val zyzz get() = Vector4i(z, y, z, z)
+	inline val zzxx get() = Vector4i(z, z, x, x)
+	inline val zzxy get() = Vector4i(z, z, x, y)
+	inline val zzxz get() = Vector4i(z, z, x, z)
+	inline val zzyx get() = Vector4i(z, z, y, x)
+	inline val zzyy get() = Vector4i(z, z, y, y)
+	inline val zzyz get() = Vector4i(z, z, y, z)
+	inline val zzzx get() = Vector4i(z, z, z, x)
+	inline val zzzy get() = Vector4i(z, z, z, y)
+	inline val zzzz get() = Vector4i(z, z, z, z)
+	inline val rr get() = Vector2i(r, r)
+	inline val rg get() = Vector2i(r, g)
+	inline val rb get() = Vector2i(r, b)
+	inline val gr get() = Vector2i(g, r)
+	inline val gg get() = Vector2i(g, g)
+	inline val gb get() = Vector2i(g, b)
+	inline val br get() = Vector2i(b, r)
+	inline val bg get() = Vector2i(b, g)
+	inline val bb get() = Vector2i(b, b)
+	inline val rrr get() = Vector3i(r, r, r)
+	inline val rrg get() = Vector3i(r, r, g)
+	inline val rrb get() = Vector3i(r, r, b)
+	inline val rgr get() = Vector3i(r, g, r)
+	inline val rgg get() = Vector3i(r, g, g)
+	inline val rgb get() = Vector3i(r, g, b)
+	inline val rbr get() = Vector3i(r, b, r)
+	inline val rbg get() = Vector3i(r, b, g)
+	inline val rbb get() = Vector3i(r, b, b)
+	inline val grr get() = Vector3i(g, r, r)
+	inline val grg get() = Vector3i(g, r, g)
+	inline val grb get() = Vector3i(g, r, b)
+	inline val ggr get() = Vector3i(g, g, r)
+	inline val ggg get() = Vector3i(g, g, g)
+	inline val ggb get() = Vector3i(g, g, b)
+	inline val gbr get() = Vector3i(g, b, r)
+	inline val gbg get() = Vector3i(g, b, g)
+	inline val gbb get() = Vector3i(g, b, b)
+	inline val brr get() = Vector3i(b, r, r)
+	inline val brg get() = Vector3i(b, r, g)
+	inline val brb get() = Vector3i(b, r, b)
+	inline val bgr get() = Vector3i(b, g, r)
+	inline val bgg get() = Vector3i(b, g, g)
+	inline val bgb get() = Vector3i(b, g, b)
+	inline val bbr get() = Vector3i(b, b, r)
+	inline val bbg get() = Vector3i(b, b, g)
+	inline val bbb get() = Vector3i(b, b, b)
+	inline val rrrr get() = Vector4i(r, r, r, r)
+	inline val rrrg get() = Vector4i(r, r, r, g)
+	inline val rrrb get() = Vector4i(r, r, r, b)
+	inline val rrgr get() = Vector4i(r, r, g, r)
+	inline val rrgg get() = Vector4i(r, r, g, g)
+	inline val rrgb get() = Vector4i(r, r, g, b)
+	inline val rrbr get() = Vector4i(r, r, b, r)
+	inline val rrbg get() = Vector4i(r, r, b, g)
+	inline val rrbb get() = Vector4i(r, r, b, b)
+	inline val rgrr get() = Vector4i(r, g, r, r)
+	inline val rgrg get() = Vector4i(r, g, r, g)
+	inline val rgrb get() = Vector4i(r, g, r, b)
+	inline val rggr get() = Vector4i(r, g, g, r)
+	inline val rggg get() = Vector4i(r, g, g, g)
+	inline val rggb get() = Vector4i(r, g, g, b)
+	inline val rgbr get() = Vector4i(r, g, b, r)
+	inline val rgbg get() = Vector4i(r, g, b, g)
+	inline val rgbb get() = Vector4i(r, g, b, b)
+	inline val rbrr get() = Vector4i(r, b, r, r)
+	inline val rbrg get() = Vector4i(r, b, r, g)
+	inline val rbrb get() = Vector4i(r, b, r, b)
+	inline val rbgr get() = Vector4i(r, b, g, r)
+	inline val rbgg get() = Vector4i(r, b, g, g)
+	inline val rbgb get() = Vector4i(r, b, g, b)
+	inline val rbbr get() = Vector4i(r, b, b, r)
+	inline val rbbg get() = Vector4i(r, b, b, g)
+	inline val rbbb get() = Vector4i(r, b, b, b)
+	inline val grrr get() = Vector4i(g, r, r, r)
+	inline val grrg get() = Vector4i(g, r, r, g)
+	inline val grrb get() = Vector4i(g, r, r, b)
+	inline val grgr get() = Vector4i(g, r, g, r)
+	inline val grgg get() = Vector4i(g, r, g, g)
+	inline val grgb get() = Vector4i(g, r, g, b)
+	inline val grbr get() = Vector4i(g, r, b, r)
+	inline val grbg get() = Vector4i(g, r, b, g)
+	inline val grbb get() = Vector4i(g, r, b, b)
+	inline val ggrr get() = Vector4i(g, g, r, r)
+	inline val ggrg get() = Vector4i(g, g, r, g)
+	inline val ggrb get() = Vector4i(g, g, r, b)
+	inline val gggr get() = Vector4i(g, g, g, r)
+	inline val gggg get() = Vector4i(g, g, g, g)
+	inline val gggb get() = Vector4i(g, g, g, b)
+	inline val ggbr get() = Vector4i(g, g, b, r)
+	inline val ggbg get() = Vector4i(g, g, b, g)
+	inline val ggbb get() = Vector4i(g, g, b, b)
+	inline val gbrr get() = Vector4i(g, b, r, r)
+	inline val gbrg get() = Vector4i(g, b, r, g)
+	inline val gbrb get() = Vector4i(g, b, r, b)
+	inline val gbgr get() = Vector4i(g, b, g, r)
+	inline val gbgg get() = Vector4i(g, b, g, g)
+	inline val gbgb get() = Vector4i(g, b, g, b)
+	inline val gbbr get() = Vector4i(g, b, b, r)
+	inline val gbbg get() = Vector4i(g, b, b, g)
+	inline val gbbb get() = Vector4i(g, b, b, b)
+	inline val brrr get() = Vector4i(b, r, r, r)
+	inline val brrg get() = Vector4i(b, r, r, g)
+	inline val brrb get() = Vector4i(b, r, r, b)
+	inline val brgr get() = Vector4i(b, r, g, r)
+	inline val brgg get() = Vector4i(b, r, g, g)
+	inline val brgb get() = Vector4i(b, r, g, b)
+	inline val brbr get() = Vector4i(b, r, b, r)
+	inline val brbg get() = Vector4i(b, r, b, g)
+	inline val brbb get() = Vector4i(b, r, b, b)
+	inline val bgrr get() = Vector4i(b, g, r, r)
+	inline val bgrg get() = Vector4i(b, g, r, g)
+	inline val bgrb get() = Vector4i(b, g, r, b)
+	inline val bggr get() = Vector4i(b, g, g, r)
+	inline val bggg get() = Vector4i(b, g, g, g)
+	inline val bggb get() = Vector4i(b, g, g, b)
+	inline val bgbr get() = Vector4i(b, g, b, r)
+	inline val bgbg get() = Vector4i(b, g, b, g)
+	inline val bgbb get() = Vector4i(b, g, b, b)
+	inline val bbrr get() = Vector4i(b, b, r, r)
+	inline val bbrg get() = Vector4i(b, b, r, g)
+	inline val bbrb get() = Vector4i(b, b, r, b)
+	inline val bbgr get() = Vector4i(b, b, g, r)
+	inline val bbgg get() = Vector4i(b, b, g, g)
+	inline val bbgb get() = Vector4i(b, b, g, b)
+	inline val bbbr get() = Vector4i(b, b, b, r)
+	inline val bbbg get() = Vector4i(b, b, b, g)
+	inline val bbbb get() = Vector4i(b, b, b, b)
+	inline val ss get() = Vector2i(s, s)
+	inline val st get() = Vector2i(s, t)
+	inline val sp get() = Vector2i(s, p)
+	inline val ts get() = Vector2i(t, s)
+	inline val tt get() = Vector2i(t, t)
+	inline val tp get() = Vector2i(t, p)
+	inline val ps get() = Vector2i(p, s)
+	inline val pt get() = Vector2i(p, t)
+	inline val pp get() = Vector2i(p, p)
+	inline val sss get() = Vector3i(s, s, s)
+	inline val sst get() = Vector3i(s, s, t)
+	inline val ssp get() = Vector3i(s, s, p)
+	inline val sts get() = Vector3i(s, t, s)
+	inline val stt get() = Vector3i(s, t, t)
+	inline val stp get() = Vector3i(s, t, p)
+	inline val sps get() = Vector3i(s, p, s)
+	inline val spt get() = Vector3i(s, p, t)
+	inline val spp get() = Vector3i(s, p, p)
+	inline val tss get() = Vector3i(t, s, s)
+	inline val tst get() = Vector3i(t, s, t)
+	inline val tsp get() = Vector3i(t, s, p)
+	inline val tts get() = Vector3i(t, t, s)
+	inline val ttt get() = Vector3i(t, t, t)
+	inline val ttp get() = Vector3i(t, t, p)
+	inline val tps get() = Vector3i(t, p, s)
+	inline val tpt get() = Vector3i(t, p, t)
+	inline val tpp get() = Vector3i(t, p, p)
+	inline val pss get() = Vector3i(p, s, s)
+	inline val pst get() = Vector3i(p, s, t)
+	inline val psp get() = Vector3i(p, s, p)
+	inline val pts get() = Vector3i(p, t, s)
+	inline val ptt get() = Vector3i(p, t, t)
+	inline val ptp get() = Vector3i(p, t, p)
+	inline val pps get() = Vector3i(p, p, s)
+	inline val ppt get() = Vector3i(p, p, t)
+	inline val ppp get() = Vector3i(p, p, p)
+	inline val ssss get() = Vector4i(s, s, s, s)
+	inline val ssst get() = Vector4i(s, s, s, t)
+	inline val sssp get() = Vector4i(s, s, s, p)
+	inline val ssts get() = Vector4i(s, s, t, s)
+	inline val sstt get() = Vector4i(s, s, t, t)
+	inline val sstp get() = Vector4i(s, s, t, p)
+	inline val ssps get() = Vector4i(s, s, p, s)
+	inline val sspt get() = Vector4i(s, s, p, t)
+	inline val sspp get() = Vector4i(s, s, p, p)
+	inline val stss get() = Vector4i(s, t, s, s)
+	inline val stst get() = Vector4i(s, t, s, t)
+	inline val stsp get() = Vector4i(s, t, s, p)
+	inline val stts get() = Vector4i(s, t, t, s)
+	inline val sttt get() = Vector4i(s, t, t, t)
+	inline val sttp get() = Vector4i(s, t, t, p)
+	inline val stps get() = Vector4i(s, t, p, s)
+	inline val stpt get() = Vector4i(s, t, p, t)
+	inline val stpp get() = Vector4i(s, t, p, p)
+	inline val spss get() = Vector4i(s, p, s, s)
+	inline val spst get() = Vector4i(s, p, s, t)
+	inline val spsp get() = Vector4i(s, p, s, p)
+	inline val spts get() = Vector4i(s, p, t, s)
+	inline val sptt get() = Vector4i(s, p, t, t)
+	inline val sptp get() = Vector4i(s, p, t, p)
+	inline val spps get() = Vector4i(s, p, p, s)
+	inline val sppt get() = Vector4i(s, p, p, t)
+	inline val sppp get() = Vector4i(s, p, p, p)
+	inline val tsss get() = Vector4i(t, s, s, s)
+	inline val tsst get() = Vector4i(t, s, s, t)
+	inline val tssp get() = Vector4i(t, s, s, p)
+	inline val tsts get() = Vector4i(t, s, t, s)
+	inline val tstt get() = Vector4i(t, s, t, t)
+	inline val tstp get() = Vector4i(t, s, t, p)
+	inline val tsps get() = Vector4i(t, s, p, s)
+	inline val tspt get() = Vector4i(t, s, p, t)
+	inline val tspp get() = Vector4i(t, s, p, p)
+	inline val ttss get() = Vector4i(t, t, s, s)
+	inline val ttst get() = Vector4i(t, t, s, t)
+	inline val ttsp get() = Vector4i(t, t, s, p)
+	inline val ttts get() = Vector4i(t, t, t, s)
+	inline val tttt get() = Vector4i(t, t, t, t)
+	inline val tttp get() = Vector4i(t, t, t, p)
+	inline val ttps get() = Vector4i(t, t, p, s)
+	inline val ttpt get() = Vector4i(t, t, p, t)
+	inline val ttpp get() = Vector4i(t, t, p, p)
+	inline val tpss get() = Vector4i(t, p, s, s)
+	inline val tpst get() = Vector4i(t, p, s, t)
+	inline val tpsp get() = Vector4i(t, p, s, p)
+	inline val tpts get() = Vector4i(t, p, t, s)
+	inline val tptt get() = Vector4i(t, p, t, t)
+	inline val tptp get() = Vector4i(t, p, t, p)
+	inline val tpps get() = Vector4i(t, p, p, s)
+	inline val tppt get() = Vector4i(t, p, p, t)
+	inline val tppp get() = Vector4i(t, p, p, p)
+	inline val psss get() = Vector4i(p, s, s, s)
+	inline val psst get() = Vector4i(p, s, s, t)
+	inline val pssp get() = Vector4i(p, s, s, p)
+	inline val psts get() = Vector4i(p, s, t, s)
+	inline val pstt get() = Vector4i(p, s, t, t)
+	inline val pstp get() = Vector4i(p, s, t, p)
+	inline val psps get() = Vector4i(p, s, p, s)
+	inline val pspt get() = Vector4i(p, s, p, t)
+	inline val pspp get() = Vector4i(p, s, p, p)
+	inline val ptss get() = Vector4i(p, t, s, s)
+	inline val ptst get() = Vector4i(p, t, s, t)
+	inline val ptsp get() = Vector4i(p, t, s, p)
+	inline val ptts get() = Vector4i(p, t, t, s)
+	inline val pttt get() = Vector4i(p, t, t, t)
+	inline val pttp get() = Vector4i(p, t, t, p)
+	inline val ptps get() = Vector4i(p, t, p, s)
+	inline val ptpt get() = Vector4i(p, t, p, t)
+	inline val ptpp get() = Vector4i(p, t, p, p)
+	inline val ppss get() = Vector4i(p, p, s, s)
+	inline val ppst get() = Vector4i(p, p, s, t)
+	inline val ppsp get() = Vector4i(p, p, s, p)
+	inline val ppts get() = Vector4i(p, p, t, s)
+	inline val pptt get() = Vector4i(p, p, t, t)
+	inline val pptp get() = Vector4i(p, p, t, p)
+	inline val ppps get() = Vector4i(p, p, p, s)
+	inline val pppt get() = Vector4i(p, p, p, t)
+	inline val pppp get() = Vector4i(p, p, p, p)
+
+	companion object {
+		@JvmField val ZERO = Vector3i()
+		@JvmField val POSITIVE_X = Vector3i(x = 1)
+		@JvmField val NEGATIVE_X = Vector3i(x = -1)
+		@JvmField val POSITIVE_Y = Vector3i(y = 1)
+		@JvmField val NEGATIVE_Y = Vector3i(y = -1)
+		@JvmField val POSITIVE_Z = Vector3i(z = 1)
+		@JvmField val NEGATIVE_Z = Vector3i(z = -1)
+	}
+}
+
+operator fun Int.times(other: Vector3i): Vector3i {
+	return Vector3i(this * other.x, this * other.y, this * other.z)
+}
+
+operator fun Int.div(other: Vector3i): Vector3i {
+	return Vector3i(this / other.x, this / other.y, this / other.z)
+}
+
+/**
+ * Mutable 3D Vector, representing three-dimensional coordinates as [Int]s
+ *
+ * It can be safely passed around to methods which expect immutable [Vector3i], **AND** do not store it,
+ * as mutable operations are separated from immutable ones
+ */
+open class MutableVector3i(
+	override var x: Int = 0,
+	override var y: Int = 0,
+	override var z: Int = 0,
+) : Vector3i(x, y, z), IMutableIntVector<MutableVector3i>, IMutableWholeVector<MutableVector3i>, IMutableVector<MutableVector3i, Vector3i>, IMatrixSetterInt {
+	constructor(input: IStruct2i, z: Int = 0) : this(input.component1(), input.component2(), z)
+	constructor(x: Int, input: IStruct2i) : this(x, input.component1(), input.component2())
+	constructor(input: IStruct3i) : this(input.component1(), input.component2(), input.component3())
+
+	override fun set(column: Int, row: Int, value: Int) {
+		if (column != 0) {
+			throw IndexOutOfBoundsException("Vectors are 1 column matrices ($column given)")
+		}
+
+		when (row) {
+			0 -> x = value
+			1 -> y = value
+			2 -> z = value
+			else -> throw IndexOutOfBoundsException("Row out of bounds: $row")
+		}
+	}
+
+	override var r by this::x
+	override var g by this::y
+	override var b by this::z
+
+	override var s by this::x
+	override var t by this::y
+	override var p by this::z
+
+	override fun equals(other: Any?): Boolean {
+		if (this === other) return true
+		if (javaClass != other?.javaClass) return false
+
+		other as MutableVector3i
+
+		if (x != other.x) return false
+		if (y != other.y) return false
+		if (z != other.z) return false
+
+		return true
+	}
+
+	override fun plusMut(other: Vector3i): MutableVector3i {
+		x += other.x
+		y += other.y
+		z += other.z
+		return this
+	}
+
+	override fun minusMut(other: Vector3i): MutableVector3i {
+		x -= other.x
+		y -= other.y
+		z -= other.z
+		return this
+	}
+
+	override fun timesMut(other: Vector3i): MutableVector3i {
+		x *= other.x
+		y *= other.y
+		z *= other.z
+		return this
+	}
+
+	override fun divMut(other: Vector3i): MutableVector3i {
+		x /= other.x
+		y /= other.y
+		z /= other.z
+		return this
+	}
+
+	override fun timesMut(other: Int): MutableVector3i {
+		x *= other
+		y *= other
+		z *= other
+		return this
+	}
+
+	override fun divMut(other: Int): MutableVector3i {
+		x /= other
+		y /= other
+		z /= other
+		return this
+	}
+}

src/test/kotlin/ru/dbotthepony/kstarbound/test/MathTests.kt

@@ -7,6 +7,10 @@ import ru.dbotthepony.kstarbound.world.CHUNK_SIZE
 import ru.dbotthepony.kstarbound.world.CHUNK_SIZE_FF
 import ru.dbotthepony.kstarbound.world.CHUNK_SIZEd
 import ru.dbotthepony.kstarbound.world.ChunkPos
+import ru.dbotthepony.kvector.matrix.matrixDeterminant
+import ru.dbotthepony.kvector.matrix.multiplyMatrix
+import ru.dbotthepony.kvector.matrix.generated.*
+import ru.dbotthepony.kvector.narray.Double2Dimensional
 
 object MathTests {
 	@Test
@@ -109,4 +113,72 @@ object MathTests {
 		check(ChunkPos.fromTilePosition(0, -CHUNK_SIZE_FF) == ChunkPos(0, -1)) { ChunkPos.fromTilePosition(0, -CHUNK_SIZE_FF) }
 		check(ChunkPos.fromTilePosition(0, -CHUNK_SIZE) == ChunkPos(0, -2)) { ChunkPos.fromTilePosition(0, -CHUNK_SIZE) }
 	}
+
+	@Test
+	fun testMatrixMult() {
+		val matrix1 = Double2Dimensional(4, 2)
+		val matrix2 = Double2Dimensional(3, 4)
+
+		matrix1[0, 0] = 3.0
+		matrix1[1, 0] = 2.0
+		matrix1[2, 0] = 1.0
+		matrix1[3, 0] = 5.0
+
+		matrix1[0, 1] = 9.0
+		matrix1[1, 1] = 1.0
+		matrix1[2, 1] = 3.0
+		matrix1[3, 1] = 0.0
+
+		matrix2[0, 0] = 2.0
+		matrix2[1, 0] = 9.0
+		matrix2[2, 0] = 0.0
+
+		matrix2[0, 1] = 1.0
+		matrix2[1, 1] = 3.0
+		matrix2[2, 1] = 5.0
+
+		matrix2[0, 2] = 2.0
+		matrix2[1, 2] = 4.0
+		matrix2[2, 2] = 7.0
+
+		matrix2[0, 3] = 8.0
+		matrix2[1, 3] = 1.0
+		matrix2[2, 3] = 5.0
+
+		val product = multiplyMatrix(matrix1, matrix2)
+
+		check(product[0, 0] == 50.0)
+		check(product[1, 0] == 42.0)
+		check(product[2, 0] == 42.0)
+
+		check(product[0, 1] == 25.0)
+		check(product[1, 1] == 96.0)
+		check(product[2, 1] == 26.0)
+	}
+
+	@Test
+	fun testAlloc() {
+		System.gc()
+
+		var t = System.currentTimeMillis()
+		var escape2 = 0.0
+
+		for (i in 0 .. 8000000) {
+			val matrix = Matrix4d()
+			escape2 += matrix[2, 3]
+		}
+
+		println(System.currentTimeMillis() - t)
+		System.gc()
+		t = System.currentTimeMillis()
+		var escape = 0.0
+
+		for (i in 0 .. 8000000) {
+			val matrix = Double2Dimensional(4, 4)
+			escape += matrix[2, 3]
+		}
+
+		println(System.currentTimeMillis() - t)
+		println(escape)
+	}
 }