ml_linalg

https://pub.dev/documentation/ml_linalg/latest
Admin
ml_linalg provides SIMD-based linear algebra and statistics for data science in Dart, featuring...
Tokens:103,377
Snippets:308
Trust Score:9.9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Example Usage of Matrix.row

Source: https://pub.dev/documentation/ml_linalg/latest/matrix/Matrix/Matrix

Demonstrates how to create and print a matrix using the Matrix.row constructor with a list of doubles.

```dart
import 'package:ml_linalg/matrix.dart';

void main() {
  final matrix = Matrix.row([1, 2, 3, 4, 5]);

  print(matrix);
}
```

--------------------------------

### SIMD Parallelism Example (Dart)

Source: https://pub.dev/documentation/ml_linalg/latest/index

This code snippet demonstrates the concept of SIMD (Single Instruction, Multiple Data) by showing how element-wise addition of two arrays can be performed in parallel, contrasting it with a sequential approach.

```Dart
final a = [10, 20, 30, 40];
final b = [50, 60, 70, 80];

// Sequential approach:
// final c = List(4);
// c[0] = a[0] + b[0]; // operation 1
// c[1] = a[1] + b[1]; // operation 2
// c[2] = a[2] + b[2]; // operation 3
// c[3] = a[3] + b[3]; // operation 4

// SIMD approach (conceptual):
// Perform element-wise sum in one step
```

--------------------------------

### Matrix Addition

Source: https://pub.dev/documentation/ml_linalg/latest/index

Provides an example of adding two matrices element-wise using the `+` operator.

```dart
import 'package:ml_linalg/linalg.dart';

final matrix1 = Matrix.fromList([
  [1.0, 2.0, 3.0, 4.0],
  [5.0, 6.0, 7.0, 8.0],
  [9.0, .0, -2.0, -3.0],
]);
final matrix2 = Matrix.fromList([
  [10.0, 20.0, 30.0, 40.0],
  [-5.0, 16.0, 2.0, 18.0],
  [2.0, -1.0, -2.0, -7.0],
]);
print(matrix1 + matrix2);

```

--------------------------------

### Vector Summation

Source: https://pub.dev/documentation/ml_linalg/latest/index

Example of performing element-wise summation between two Vector instances.

```dart
import 'package:ml_linalg/linalg.dart';

final vector1 = Vector.fromList([1.0, 2.0, 3.0, 4.0, 5.0]);
final vector2 = Vector.fromList([2.0, 3.0, 4.0, 5.0, 6.0]);
final result = vector1 + vector2;

print(result.toList()); // [3.0, 5.0, 7.0, 9.0, 11.0]
```

--------------------------------

### Vector Subtraction

Source: https://pub.dev/documentation/ml_linalg/latest/index

Example of performing element-wise subtraction between two Vector instances.

```dart
import 'package:ml_linalg/linalg.dart';

final vector1 = Vector.fromList([4.0, 5.0, 6.0, 7.0, 8.0]);
final vector2 = Vector.fromList([2.0, 3.0, 2.0, 3.0, 2.0]);
final result = vector1 - vector2;

print(result.toList()); // [2.0, 2.0, 4.0, 4.0, 6.0]
```

--------------------------------

### Matrix Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/matrix/Matrix/fastMap

API documentation for the Matrix class, covering constructors, properties, methods, and operators for matrix manipulation in ml_linalg.

```APIDOC
##### Matrix class
  1. Constructors
  2. column
  3. diagonal
  4. empty
  5. fromByteData
  6. fromColumns
  7. fromFlattenedList
  8. fromJson
  9. fromList
  10. fromRows
  11. identity
  12. random
  13. randomSPD
  14. row
  15. scalar
  16. Properties
  17. asFlattenedList
  18. columnCount
  19. columnIndices
  20. columns
  21. columnsNum
  22. dtype
  23. first
  24. hasData
  25. hashCode
  26. isEmpty
  27. isNotEmpty
  28. isSquare
  29. iterator
  30. last
  31. length
  32. rowCount
  33. rowIndices
  34. rows
  35. rowsNum
  36. runtimeType
  37. single
  38. Methods
  39. any
  40. cast
  41. contains
  42. decompose
  43. deviation
  44. eigen
  45. elementAt
  46. every
  47. exp
  48. expand
  49. fastMap
  50. filterColumns
  51. firstWhere
  52. fold
  53. followedBy
  54. forEach
  55. getColumn
  56. getRow
  57. insertColumns
  58. inverse
  59. join
  60. lastWhere
  61. log
  62. map
  63. mapColumns
  64. mapElements
  65. mapRows
  66. max
  67. mean
  68. min
  69. multiply
  70. norm
  71. noSuchMethod
  72. pow
  73. prod
  74. reduce
  75. reduceColumns
  76. reduceRows
  77. sample
  78. singleWhere
  79. skip
  80. skipWhile
  81. solve
  82. sort
  83. sum
  84. take
  85. takeWhile
  86. toJson
  87. toList
  88. toSet
  89. toString
  90. toVector
  91. transpose
  92. uniqueRows
  93. variance
  94. where
  95. whereType
  96. Operators
  97. operator *
  98. operator +
  99. operator -
  100. operator /
  101. operator ==
  102. operator []
```

--------------------------------

### Create Identity Matrix

Source: https://pub.dev/documentation/ml_linalg/latest/index

Demonstrates the creation of an identity matrix of a specified size using `Matrix.identity()`.

```dart
import 'package:ml_linalg/matrix.dart';

final matrix = Matrix.identity(5);

print(matrix);

```

--------------------------------

### Matrix Cholesky Decomposition

Source: https://pub.dev/documentation/ml_linalg/latest/index

Provides an example of Cholesky decomposition on a symmetric, positive-definite matrix using `decompose(Decomposition.cholesky)`.

```dart
final matrix = Matrix.fromList([
  [4, 12, -16],
  [12, 37, -43],
  [-16, -43, 98],
], dtype: dtype);
final decomposed = matrix.decompose(Decomposition.cholesky);

// yields approximately the same matrix as the original one:
print(decomposed.first * decomposed.last);

```

--------------------------------

### Vector Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/vector/Vector/rescale

Comprehensive API documentation for the Vector class in ml_linalg. Includes constructors, properties, methods (like abs, dot, rescale, sum), and operators (+, -, *, /).

```APIDOC
Vector:
  Constructors:
    empty()
    filled(double value)
    fromJson(Map<String, dynamic> json)
    fromList(List<double> list)
    fromSimdList(List<double> list)
    randomFilled(double min, double max)
    zero(int size)
  Properties:
    dtype: The data type of the vector elements.
    first: The first element of the vector.
    hashCode: The hash code for the vector.
    isEmpty: True if the vector is empty.
    isNotEmpty: True if the vector is not empty.
    iterator: An iterator for the vector elements.
    last: The last element of the vector.
    length: The number of elements in the vector.
    runtimeType: The runtime type of the vector.
    single: The single element of a vector with one element.
  Methods:
    abs(): Returns a vector with the absolute value of each element.
    any(bool Function(double) predicate): Checks if any element satisfies the predicate.
    cast<T>(): Casts the vector to a different type (if applicable).
    contains(double element): Checks if the vector contains the given element.
    distanceTo(Vector other): Calculates the Euclidean distance to another vector.
    dot(Vector other): Computes the dot product with another vector.
    elementAt(int index): Returns the element at the specified index.
    every(bool Function(double) predicate): Checks if all elements satisfy the predicate.
    exp(): Returns a vector with the exponential of each element.
    expand<S>(Iterable<S> Function(double) f): Expands each element into an iterable.
    fastMap(double Function(double) f): Applies a function to each element (optimized).
    filterElements(bool Function(double) predicate): Returns a new vector with elements that satisfy the predicate.
    firstWhere(bool Function(double) test, {double Function()? orElse}): Returns the first element that satisfies the predicate.
    fold<S>(S initialValue, S Function(S, double) combine): Reduces the vector to a single value.
    followedBy(Iterable<double> other): Returns an iterable that combines this vector with another.
    forEach(void Function(double) action): Executes an action for each element.
    getCosine(Vector other): Calculates the cosine similarity with another vector.
    join(String separator): Joins elements into a string with a separator.
    lastWhere(bool Function(double) test, {double Function()? orElse}): Returns the last element that satisfies the predicate.
    log(): Returns a vector with the natural logarithm of each element.
    map<S>(S Function(double) f): Applies a function to each element.
    mapToVector(double Function(double) f): Applies a function and returns a new Vector.
    max(): Returns the maximum element in the vector.
    mean(): Calculates the mean of the vector elements.
    median(): Calculates the median of the vector elements.
    min(): Returns the minimum element in the vector.
    norm(): Calculates the Euclidean norm (magnitude) of the vector.
    normalize(): Returns a normalized version of the vector (unit length).
    noSuchMethod(Invocation invocation): Invoked when a non-existent method or property is accessed.
    pow(double exponent): Returns a vector with each element raised to the given exponent.
    prod(): Calculates the product of all elements in the vector.
    reduce(double Function(double, double) operation):
    rescale({bool skipCaching = false}): Returns a rescaled (min-max normed) version of this vector.
    sample(int count, {bool replace = false}): Returns a random sample of elements.
    scalarDiv(double scalar): Divides each element by a scalar.
    set(int index, double value): Sets the element at the specified index.
    singleWhere(bool Function(double) test, {double Function()? orElse}): Returns the single element that satisfies the predicate.
    skip(int count): Returns a new iterable skipping the first `count` elements.
    skipWhile(bool Function(double) test): Returns a new iterable skipping elements while the predicate is true.
    sqrt(): Returns a vector with the square root of each element.
    subvector(int start, int end): Returns a sub-vector from start (inclusive) to end (exclusive).
    sum(): Calculates the sum of the vector elements.
    take(int count): Returns a new iterable taking the first `count` elements.
    takeWhile(bool Function(double) test): Returns a new iterable taking elements while the predicate is true.
    toJson(): Converts the vector to a JSON-compatible map.
    toList(): Converts the vector to a List.
    toSet(): Converts the vector to a Set.
    toString(): Returns a string representation of the vector.
    unique(): Returns a new vector with unique elements.
    where(bool Function(double) predicate): Returns a new vector with elements that satisfy the predicate.
    whereType<S>(): Returns a new vector containing elements of a specific type.
  Operators:
    operator *(dynamic other): Multiplies the vector by another vector or scalar.
    operator +(dynamic other): Adds another vector or scalar to this vector.
    operator -(dynamic other): Subtracts another vector or scalar from this vector.
    operator /(dynamic other): Divides this vector by another vector or scalar.
    operator ==(Object other): Checks for equality with another object.
```

--------------------------------

### ml_linalg Package Libraries

Source: https://pub.dev/documentation/ml_linalg/latest/axis

Lists the available libraries within the ml_linalg package, covering linear algebra operations, data structures, and utility functions.

```text
ml_linalg package libraries:
- axis
- decomposition
- distance
- distance_type_to_json
- dtype
- dtype_to_json
- from_distance_type_json
- from_dtype_json
- from_matrix_json
- from_vector_json
- inverse
- linalg
- matrix
- matrix_norm
- matrix_to_json
- norm
- sort_direction
- vector
- vector_to_json
```

--------------------------------

### Get Min Value of Matrix

Source: https://pub.dev/documentation/ml_linalg/latest/index

Retrieves the minimum value present in the matrix. This operation iterates through all elements to find the single smallest value.

```Dart
import 'package:ml_linalg/linalg.dart';

final matrix = Matrix.fromList([
  [11.0, 12.0, 13.0, 14.0],
  [15.0, 16.0, 0.0, 18.0],
  [21.0, 22.0, -23.0, 24.0],
  [24.0, 32.0, 53.0, 74.0],
]);
final minValue = matrix.min();
print(minValue);
// -23.0
```

--------------------------------

### Vector as HashMap Key

Source: https://pub.dev/documentation/ml_linalg/latest/index

Demonstrates using Vector instances as keys in a HashMap, leveraging their consistent hashCode for equal vectors.

```dart
import 'package:ml_linalg/vector.dart';
import 'dart:collection';

final map = HashMap<Vector, bool>();

map[Vector.fromList([1, 2, 3, 4, 5])] = true;

print(map[Vector.fromList([1, 2, 3, 4, 5])]); // true
print(Vector.fromList([1, 2, 3, 4, 5]).hashCode == Vector.fromList([1, 2, 3, 4, 5]).hashCode); // true
```

--------------------------------

### Get Max Value of Matrix

Source: https://pub.dev/documentation/ml_linalg/latest/index

Retrieves the maximum value present in the matrix. This operation iterates through all elements to find the single largest value.

```Dart
import 'package:ml_linalg/linalg.dart';

final matrix = Matrix.fromList([
  [11.0, 12.0, 13.0, 14.0],
  [15.0, 16.0, 17.0, 18.0],
  [21.0, 22.0, 23.0, 24.0],
  [24.0, 32.0, 53.0, 74.0],
]);
final maxValue = matrix.max();
print(maxValue);
// 74.0
```

--------------------------------

### Matrix Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/matrix/Matrix/rows

Comprehensive API documentation for the Matrix class in ml_linalg. Covers constructors, properties, methods, and operators for matrix operations.

```APIDOC
##### Matrix class

**Constructors:**
- column
- diagonal
- empty
- fromByteData
- fromColumns
- fromFlattenedList
- fromJson
- fromList
- fromRows
- identity
- random
- randomSPD
- row
- scalar

**Properties:**
- asFlattenedList
- columnCount
- columnIndices
- columns
- columnsNum
- dtype
- first
- hasData
- hashCode
- isEmpty
- isNotEmpty
- isSquare
- iterator
- last
- length
- rowCount
- rowIndices
- rows
- rowsNum
- runtimeType
- single

**Methods:**
- any
- cast
- contains
- decompose
- deviation
- eigen
- elementAt
- every
- exp
- expand
- fastMap
- filterColumns
- firstWhere
- fold
- followedBy
- forEach
- getColumn
- getRow
- insertColumns
- inverse
- join
- lastWhere
- log
- map
- mapColumns
- mapElements
- mapRows
- max
- mean
- min
- multiply
- norm
- noSuchMethod
- pow
- prod
- reduce
- reduceColumns
- reduceRows
- sample
- singleWhere
- skip
- skipWhile
- solve
- sort
- sum
- take
- takeWhile
- toJson
- toList
- toSet
- toString
- toVector
- transpose
- uniqueRows
- variance
- where
- whereType

**Operators:**
- operator *
- operator +
- operator -
- operator /
- operator ==
- operator []
```

--------------------------------

### Matrix Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/matrix/Matrix/exp

Comprehensive API documentation for the Matrix class in ml_linalg. Covers constructors, properties, methods, and operators for matrix manipulation and mathematical operations.

```APIDOC
##### Matrix class

**Constructors:**
- column(int count)
- diagonal(Iterable<num> values)
- empty(int rowCount, int columnCount)
- fromByteData(int rowCount, int columnCount, ByteData data)
- fromColumns(Iterable<List<num>> columns)
- fromFlattenedList(int rowCount, int columnCount, List<num> list)
- fromJson(String json)
- fromList(List<List<num>> list)
- fromRows(Iterable<List<num>> rows)
- identity(int size)
- random(int rowCount, int columnCount, {double min = 0.0, double max = 1.0})
- randomSPD(int size, {double min = 0.0, double max = 1.0})
- row(int rowCount)
- scalar(int rowCount, int columnCount, num value)

**Properties:**
- asFlattenedList: List<num>
- columnCount: int
- columnIndices: Iterable<int>
- columns: List<List<num>>
- columnsNum: int
- dtype: Type
- first: num
- hasData: bool
- hashCode: int
- isEmpty: bool
- isNotEmpty: bool
- isSquare: bool
- iterator: Iterator<num>
- last: num
- length: int
- rowCount: int
- rowIndices: Iterable<int>
- rows: List<List<num>>
- rowsNum: int
- runtimeType: Type
- single: num

**Methods:**
- any(bool Function(num element) test)
- cast<R extends num>(): Matrix<R>
- contains(num element): bool
- decompose(): Decomposition
- deviation(): num
- eigen(): EigenDecomposition
- elementAt(int index): num
- every(bool Function(num element) test): bool
- exp({@Deprecated('The flag is useless, it\'ll be removed in the next major update') bool skipCaching = false}): Matrix
- expand(Iterable<num> iterable): Matrix
- fastMap(num Function(num element) f): Matrix
- filterColumns(bool Function(List<num> column) predicate): Matrix
- firstWhere(bool Function(num element) test, {num Function()? orElse}): num
- fold<S>(S initialValue, S Function(S accumulator, num element) combine): S
- followedBy(Iterable<num> other): Iterable<num>
- forEach(void Function(num element) action): void
- getColumn(int index): List<num>
- getRow(int index): List<num>
- insertColumns(int index, Iterable<List<num>> columns): Matrix
- inverse(): Matrix
- join(String separator, {String Function(num element)? valueToString}): String
- lastWhere(bool Function(num element) test, {num Function()? orElse}): num
- log(): Matrix
- map<R extends num>(R Function(num element) toElement): Matrix<R>
- mapColumns(List<num> Function(List<num> column) f): Matrix
- mapElements(num Function(num element) f): Matrix
- mapRows(List<num> Function(List<num> row) f): Matrix
- max(): num
- mean(): num
- min(): num
- multiply(Matrix other): Matrix
- norm({NormType type = NormType.frobenius}): num
- noSuchMethod(Invocation invocation): dynamic
- pow(num exponent): Matrix
- prod(): num
- reduce(num Function(num previous, num element) combine): num
- reduceColumns(List<num> Function(List<num> column) combiner): List<num>
- reduceRows(List<num> Function(List<num> row) combiner): List<num>
- sample(int count): List<num>
- singleWhere(bool Function(num element) test, {num Function()? orElse}): num
- skip(int count): Iterable<num>
- skipWhile(bool Function(num element) test): Iterable<num>
- solve(Matrix other): Matrix
- sort({bool Function(num a, num b)? compare}): Matrix
- sum(): num
- take(int count): Iterable<num>
- takeWhile(bool Function(num element) test): Iterable<num>
- toJson(): String
- toList(): List<List<num>>
- toSet(): Set<num>
- toString(): String
- toVector(): List<num>
- transpose(): Matrix
- uniqueRows(): Matrix
- variance(): num
- where(bool Function(num element) test): Iterable<num>
- whereType<R extends num>(): Iterable<R>

**Operators:**
- operator *(Matrix other): Matrix
- operator +(Matrix other): Matrix
- operator -(Matrix other): Matrix
- operator /(Matrix other): Matrix
- operator ==(Object other): bool
- operator [](int index): List<num>
```

--------------------------------

### Vector Class Methods

Source: https://pub.dev/documentation/ml_linalg/latest/vector/Vector/operator_minus

A collection of methods available for the Vector class, covering mathematical computations, data manipulation, and utility functions. Examples include 'abs', 'dot', 'sum', 'toJson', and 'toList'.

```dart
abs
any
cast
contains
distanceTo
dot
elementAt
every
exp
expand
fastMap
filterElements
firstWhere
fold
followedBy
forEach
getCosine
join
lastWhere
log
map
mapToVector
max
mean
median
min
norm
normalize
noSuchMethod
pow
prod
reduce
rescale
sample
scalarDiv
set
singleWhere
skip
skipWhile
sqrt
subvector
sum
take
takeWhile
toJson
toList
toSet
toString
unique
where
whereType
```

--------------------------------

### Matrix Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/matrix/Matrix/decompose

API reference for the Matrix class in ml_linalg, covering constructors, properties, methods, and operators for matrix operations.

```APIDOC
##### Matrix class

**Constructors:**
- column(List<List<num>> columns)
- diagonal(List<num> diagonal)
- empty()
- fromByteData(ByteData data, {int rowCount, int columnCount})
- fromColumns(List<List<num>> columns)
- fromFlattenedList(List<num> list, {int rowCount, int columnCount})
- fromJson(Map<String, dynamic> json)
- fromList(List<List<num>> list)
- fromRows(List<List<num>> rows)
- identity(int size)
- random({int rowCount, int columnCount, num min, num max})
- randomSPD({int size, num min, num max})
- row(List<List<num>> rows)
- scalar(num value, {int rowCount, int columnCount})

**Properties:**
- asFlattenedList: List<num>
- columnCount: int
- columnIndices: Iterable<int>
- columns: List<List<num>>
- columnsNum: int
- dtype: Type
- first: num
- hasData: bool
- hashCode: int
- isEmpty: bool
- isNotEmpty: bool
- isSquare: bool
- iterator: Iterator<num>
- last: num
- length: int
- rowCount: int
- rowIndices: Iterable<int>
- rows: List<List<num>>
- rowsNum: int
- runtimeType: Type
- single: num

**Methods:**
- any(bool Function(num) test): bool
- cast<R>(): Matrix<R>
- contains(num element): bool
- decompose([Decomposition decompositionType]): Iterable<Matrix>
- deviation({bool isSample}): num
- eigen(): EigenDecomposition
- elementAt(int index): num
- every(bool Function(num) test): bool
- exp(): Matrix
- expand(Iterable<num> values, {int rowCount, int columnCount}): Matrix
- fastMap(num Function(num) f): Matrix
- filterColumns(bool Function(List<num>) predicate): Matrix
- firstWhere(bool Function(num) test, {num Function() orElse}): num
- fold(R initialValue, R Function(R, num) combine): R
- followedBy(Iterable<num> other): Iterable<num>
- forEach(void Function(num) action): void
- getColumn(int index): List<num>
- getRow(int index): List<num>
- insertColumns(int index, List<List<num>> columns): Matrix
- inverse(): Matrix
- join(String separator): String
- lastWhere(bool Function(num) test, {num Function() orElse}): num
- log(): Matrix
- map(num Function(num) f): Matrix
- mapColumns(List<num> Function(List<num>) f): Matrix
- mapElements(num Function(num) f): Matrix
- mapRows(List<num> Function(List<num>) f): Matrix
- max(): num
- mean(): num
- min(): num
- multiply(Matrix other): Matrix
- norm({String order}): num
- noSuchMethod(Invocation invocation): dynamic
- pow(num exponent): Matrix
- prod(): num
- reduce(num Function(num, num) combine): num
- reduceColumns(List<num> Function(List<num>) f): Matrix
- reduceRows(List<num> Function(List<num>) f): Matrix
- sample({int rowCount, int columnCount}): Matrix
- singleWhere(bool Function(num) test, {num Function() orElse}): num
- skip(int count): Iterable<num>
- skipWhile(bool Function(num) test): Iterable<num>
- solve(Matrix rhs): Matrix
- sort({Comparator<num>? compare}): Matrix
- sum(): num
- take(int count): Iterable<num>
- takeWhile(bool Function(num) test): Iterable<num>
- toJson(): Map<String, dynamic>
- toList(): List<num>
- toSet(): Set<num>
- toString(): String
- toVector(): Vector
- transpose(): Matrix
- uniqueRows(): Matrix
- variance({bool isSample}): num
- where(bool Function(num) test): Iterable<num>
- whereType<R>(): Iterable<R>

**Operators:**
- operator *(Matrix other): Matrix
- operator +(Matrix other): Matrix
- operator -(Matrix other): Matrix
- operator /(Matrix other): Matrix
- operator ==(Object other): bool
- operator [](int index): List<num>
```

--------------------------------

### Vector subvector Method

Source: https://pub.dev/documentation/ml_linalg/latest/vector/Vector/subvector

The `subvector` method returns a new vector composed of values from the original vector whose indices fall within a specified range. The range is defined by a start index (inclusive) and an end index (exclusive).

```dart
Vector subvector(
  int start, [
  int? end
]);
```

--------------------------------

### Get Matrix as Flattened List

Source: https://pub.dev/documentation/ml_linalg/latest/matrix/Matrix/asFlattenedList

The `asFlattenedList` property returns a representation of the matrix as a flattened list of doubles. The runtime type can be `Float32List` or `Float64List`, depending on the matrix's `dtype`. This is useful for operations that require a one-dimensional array of the matrix's elements.

```dart
import 'package:ml_linalg/matrix.dart';

void main() {
  final matrix = Matrix.fromList([
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0],
  ]);

  print(matrix.asFlattenedList); // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
}
```

```APIDOC
List<double> get asFlattenedList;

Returns a representation of the matrix as a flattened list.
```

--------------------------------

### Matrix Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/matrix/Matrix/mapRows

Provides a comprehensive overview of the Matrix class in ml_linalg, including constructors for creating matrices, properties for accessing matrix attributes, and methods for performing various mathematical operations.

```APIDOC
##### Matrix class
  1. Constructors
    - column
    - diagonal
    - empty
    - fromByteData
    - fromColumns
    - fromFlattenedList
    - fromJson
    - fromList
    - fromRows
    - identity
    - random
    - randomSPD
    - row
    - scalar
  2. Properties
    - asFlattenedList
    - columnCount
    - columnIndices
    - columns
    - columnsNum
    - dtype
    - first
    - hasData
    - hashCode
    - isEmpty
    - isNotEmpty
    - isSquare
    - iterator
    - last
    - length
    - rowCount
    - rowIndices
    - rows
    - rowsNum
    - runtimeType
    - single
  3. Methods
    - any
    - cast
    - contains
    - decompose
    - deviation
    - eigen
    - elementAt
    - every
    - exp
    - expand
    - fastMap
    - filterColumns
    - firstWhere
    - fold
    - followedBy
    - forEach
    - getColumn
    - getRow
    - insertColumns
    - inverse
    - join
    - lastWhere
    - log
    - map
    - mapColumns
    - mapElements
    - mapRows
    - max
    - mean
    - min
    - multiply
    - norm
    - noSuchMethod
    - pow
    - prod
    - reduce
    - reduceColumns
    - reduceRows
    - sample
    - singleWhere
    - skip
    - skipWhile
    - solve
    - sort
    - sum
    - take
    - takeWhile
    - toJson
    - toList
    - toSet
    - toString
    - toVector
    - transpose
    - uniqueRows
    - variance
    - where
    - whereType
  4. Operators
    - operator *
    - operator +
    - operator -
    - operator /
    - operator ==
    - operator []
```

--------------------------------

### Vector Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/vector/Vector/mean

Comprehensive API documentation for the Vector class in ml_linalg. Covers constructors, properties, methods, and operators.

```APIDOC
Vector Class

Constructors:
  - empty()
  - filled(double value)
  - fromJson(Map<String, dynamic> json)
  - fromList(List<double> list)
  - fromSimdList(List<double> list)
  - randomFilled(double min, double max)
  - zero(int length)

Properties:
  - dtype: The data type of the vector elements.
  - first: The first element of the vector.
  - hashCode: The hash code of the vector.
  - isEmpty: True if the vector is empty.
  - isNotEmpty: True if the vector is not empty.
  - iterator: An iterator for the vector elements.
  - last: The last element of the vector.
  - length: The number of elements in the vector.
  - runtimeType: The runtime type of the vector.
  - single: The single element of a vector with one element.

Methods:
  - abs(): Returns a vector with the absolute values of each element.
  - any(bool Function(double) predicate): Checks if any element satisfies the predicate.
  - cast<T>(): Casts the vector to a different type (if applicable).
  - contains(double element): Checks if the vector contains the specified element.
  - distanceTo(Vector other): Calculates the Euclidean distance to another vector.
  - dot(Vector other): Computes the dot product with another vector.
  - elementAt(int index): Returns the element at the specified index.
  - every(bool Function(double) predicate): Checks if all elements satisfy the predicate.
  - exp(): Returns a vector with the exponential of each element.
  - expand(Iterable<double> Function(double) f): Expands each element into an iterable.
  - fastMap(double Function(double) f): Applies a function to each element (optimized).
  - filterElements(bool Function(double) predicate): Returns a new vector with elements that satisfy the predicate.
  - firstWhere(bool Function(double) test, {double Function()? orElse}): Returns the first element that satisfies the test.
  - fold<R>(R initialValue, R Function(R, double) combine): Reduces the vector to a single value.
  - followedBy(Iterable<double> other): Returns an iterable that combines this vector with another.
  - forEach(void Function(double) action): Executes an action for each element.
  - getCosine(Vector other): Calculates the cosine similarity with another vector.
  - join([String separator = '']): Joins elements into a string.
  - lastWhere(bool Function(double) test, {double Function()? orElse}): Returns the last element that satisfies the test.
  - log(): Returns a vector with the natural logarithm of each element.
  - map<R>(R Function(double) f): Creates a new vector by applying a function to each element.
  - mapToVector(Vector Function(double) f): Creates a new vector by applying a function that returns a vector to each element.
  - max(): Returns the maximum value in the vector.
  - mean({bool skipCaching = false}): Returns the mean value of the vector.
  - median(): Returns the median value of the vector.
  - min(): Returns the minimum value in the vector.
  - norm({double p = 2.0}): Calculates the p-norm of the vector.
  - normalize({double p = 2.0}): Normalizes the vector to have a specific p-norm.
  - noSuchMethod(Invocation invocation): Invoked when a non-existent method or property is accessed.
  - pow(double exponent): Returns a vector with each element raised to the given exponent.
  - prod(): Returns the product of all elements in the vector.
  - reduce(double Function(double, double) combine): Reduces the vector to a single value using a combine function.
  - rescale(double factor): Rescales the vector by a factor.
  - sample(int count): Returns a random sample of elements from the vector.
  - scalarDiv(double scalar): Divides each element by a scalar.
  - set(int index, double value): Sets the element at the specified index.
  - singleWhere(bool Function(double) test, {double Function()? orElse}): Returns the single element that satisfies the test.
  - skip(int count): Returns a new iterable that skips the first `count` elements.
  - skipWhile(bool Function(double) test): Returns a new iterable that skips elements while the test is true.
  - sqrt(): Returns a vector with the square root of each element.
  - subvector(int start, int end): Returns a sub-vector from start (inclusive) to end (exclusive).
  - sum(): Returns the sum of all elements in the vector.
  - take(int count): Returns a new iterable that contains the first `count` elements.
  - takeWhile(bool Function(double) test): Returns a new iterable that takes elements while the test is true.
  - toJson(): Converts the vector to a JSON-compatible map.
  - toList(): Converts the vector to a List.
  - toSet(): Converts the vector to a Set.
  - toString(): Returns a string representation of the vector.
  - unique(): Returns a new vector with unique elements.
  - where(bool Function(double) predicate): Returns a new iterable with elements that satisfy the predicate.
  - whereType<T>(): Returns a new iterable with elements of the specified type.

Operators:
  - operator *(Vector other): Element-wise multiplication.
  - operator +(Vector other): Element-wise addition.
  - operator -(Vector other): Element-wise subtraction.
  - operator /(Vector other): Element-wise division.
  - operator ==(Object other): Checks for equality with another object.
  - operator [](int index): Accesses the element at the specified index.
```

--------------------------------

### Vector Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/vector/Vector/sqrt

Comprehensive API documentation for the Vector class in ml_linalg. Covers constructors, properties, methods, and operators for vector manipulation and mathematical operations.

```APIDOC
Vector class:

Constructors:
  - empty()
  - filled(double value)
  - fromJson(Map<String, dynamic> json)
  - fromList(List<double> list)
  - fromSimdList(List<double> list)
  - randomFilled(double min, double max)
  - zero(int length)

Properties:
  - dtype: The data type of the vector elements.
  - first: The first element of the vector.
  - hashCode: The hash code of the vector.
  - isEmpty: Returns true if the vector is empty.
  - isNotEmpty: Returns true if the vector is not empty.
  - iterator: An iterator for the vector elements.
  - last: The last element of the vector.
  - length: The number of elements in the vector.
  - runtimeType: The runtime type of the vector.
  - single: The single element of a vector with one element.

Methods:
  - abs(): Returns a new Vector with the absolute values of elements.
  - any(bool Function(double) predicate): Checks if any element satisfies the predicate.
  - cast<T>(): Casts the vector to a different type (if applicable).
  - contains(double element): Checks if the vector contains the given element.
  - distanceTo(Vector other): Calculates the Euclidean distance to another vector.
  - dot(Vector other): Calculates the dot product with another vector.
  - elementAt(int index): Returns the element at the specified index.
  - every(bool Function(double) predicate): Checks if all elements satisfy the predicate.
  - exp(): Returns a new Vector with the exponential of elements.
  - expand(Iterable<double> Function(double) f): Expands elements into an iterable.
  - fastMap(double Function(double) f): Applies a function to each element (optimized).
  - filterElements(bool Function(double) predicate): Filters elements based on a predicate.
  - firstWhere(bool Function(double) test, {double Function()? orElse}): Returns the first element that satisfies the test.
  - fold(T initialValue, T Function(T, double) combine): Reduces the vector to a single value.
  - followedBy(Iterable<double> other): Returns an iterable with elements followed by another iterable.
  - forEach(void Function(double) action): Executes an action for each element.
  - getCosine(Vector other): Calculates the cosine similarity with another vector.
  - join([String separator = '']): Joins vector elements into a string.
  - lastWhere(bool Function(double) test, {double Function()? orElse}): Returns the last element that satisfies the test.
  - log(): Returns a new Vector with the natural logarithm of elements.
  - map<R>(R Function(double) f): Applies a function to each element and returns a new Vector.
  - mapToVector(double Function(double) f): Maps elements to a new Vector.
  - max(): Returns the maximum element in the vector.
  - mean(): Calculates the mean of the vector elements.
  - median(): Calculates the median of the vector elements.
  - min(): Returns the minimum element in the vector.
  - norm(double p = 2.0): Calculates the p-norm of the vector.
  - normalize(): Normalizes the vector (L2 norm).
  - noSuchMethod(Invocation invocation): Invoked when a non-existent method is called.
  - pow(double exponent): Raises each element to the given exponent.
  - prod(): Calculates the product of all elements.
  - reduce(double Function(double, double) combine): Reduces the vector to a single value.
  - rescale(double factor): Rescales the vector by a factor.
  - sample(int count): Returns a random sample of elements.
  - scalarDiv(double scalar): Divides each element by a scalar.
  - set(int index, double value): Sets the element at the specified index.
  - singleWhere(bool Function(double) test, {double Function()? orElse}): Returns the single element that satisfies the test.
  - skip(int count): Returns an iterable skipping the first 'count' elements.
  - skipWhile(bool Function(double) test): Skips elements while the test is true.
  - sqrt(): Returns a new Vector with the square root of elements.
  - subvector(int start, int end): Returns a sub-vector.
  - sum(): Calculates the sum of the vector elements.
  - take(int count): Returns an iterable taking the first 'count' elements.
  - takeWhile(bool Function(double) test): Takes elements while the test is true.
  - toJson(): Converts the vector to a JSON-compatible map.
  - toList(): Converts the vector to a List.
  - toSet(): Converts the vector to a Set.
  - toString(): Returns a string representation of the vector.
  - unique(): Returns a new Vector with unique elements.
  - where(bool Function(double) predicate): Returns an iterable of elements satisfying the predicate.
  - whereType<T>(): Returns an iterable of elements of a specific type.

Operators:
  - operator *(Vector other): Element-wise multiplication.
  - operator +(Vector other): Element-wise addition.
  - operator -(Vector other): Element-wise subtraction.
  - operator /(Vector other): Element-wise division.
  - operator ==(Object other): Checks for equality with another object.
  - operator [](int index): Accesses the element at the specified index.
```

--------------------------------

### Matrix Class API Documentation

Source: https://pub.dev/documentation/ml_linalg/latest/matrix/Matrix/mean

Comprehensive API documentation for the Matrix class, detailing its constructors, properties, methods, and operators for linear algebra operations.

```APIDOC
##### Matrix class

**Constructors:**
- column
- diagonal
- empty
- fromByteData
- fromColumns
- fromFlattenedList
- fromJson
- fromList
- fromRows
- identity
- random
- randomSPD
- row
- scalar

**Properties:**
- asFlattenedList
- columnCount
- columnIndices
- columns
- columnsNum
- dtype
- first
- hasData
- hashCode
- isEmpty
- isNotEmpty
- isSquare
- iterator
- last
- length
- rowCount
- rowIndices
- rows
- rowsNum
- runtimeType
- single

**Methods:**
- any
- cast
- contains
- decompose
- deviation
- eigen
- elementAt
- every
- exp
- expand
- fastMap
- filterColumns
- firstWhere
- fold
- followedBy
- forEach
- getColumn
- getRow
- insertColumns
- inverse
- join
- lastWhere
- log
- map
- mapColumns
- mapElements
- mapRows
- max
- mean
- min
- multiply
- norm
- noSuchMethod
- pow
- prod
- reduce
- reduceColumns
- reduceRows
- sample
- singleWhere
- skip
- skipWhile
- solve
- sort
- sum
- take
- takeWhile
- toJson
- toList
- toSet
- toString
- toVector
- transpose
- uniqueRows
- variance
- where
- whereType

**Operators:**
- operator *
- operator +
- operator -
- operator /
- operator ==
- operator []
```
Tokens:
Raw