1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

//! Matrix laboratory.
//!
//! ## Formats
//!
//! The following storage formats are supported:
//!
//! * [Banded][banded], suitable for matrices with a small number of
//!   superdiagonals and/or subdiagonals;
//!
//! * [Compressed][compressed], suitable for generic sparse matrices;
//!
//! * [Conventional][conventional], suitable for dense matrices;
//!
//! * [Diagonal][diagonal], suitable for diagonal matrices; and
//!
//! * [Packed][packed], suitable for symmetric, Hermitian, and triangular
//!   matrices.
//!
//! ## Example
//!
//! ```
//! #[macro_use]
//! extern crate matrix;
//!
//! use matrix::prelude::*;
//!
//! # fn main() {
//! let mut sparse = Compressed::zero((2, 4));
//! sparse.set((0, 0), 42.0);
//! sparse.set((1, 3), 69.0);
//!
//! let dense = Conventional::from(&sparse);
//! assert_eq!(&*dense, &*matrix![
//!     42.0, 0.0, 0.0,  0.0;
//!      0.0, 0.0, 0.0, 69.0;
//! ]);
//! # }
//! ```
//!
//! [banded]: https://stainless-steel.github.io/matrix/matrix/format/banded
//! [compressed]: https://stainless-steel.github.io/matrix/matrix/format/compressed
//! [conventional]: https://stainless-steel.github.io/matrix/matrix/format/conventional
//! [diagonal]: https://stainless-steel.github.io/matrix/matrix/format/diagonal
//! [packed]: https://stainless-steel.github.io/matrix/matrix/format/packed

#[cfg(test)]
extern crate assert;

#[cfg(feature = "acceleration")]
extern crate blas;

#[cfg(feature = "acceleration")]
extern crate lapack;

extern crate num_complex;
extern crate num_traits;

pub use num_traits::Num as Number;

/// A complex number with 32-bit parts.
#[allow(non_camel_case_types)]
pub type c32 = num_complex::Complex<f32>;

/// A complex number with 64-bit parts.
#[allow(non_camel_case_types)]
pub type c64 = num_complex::Complex<f64>;

use std::convert::Into;
use std::{error, fmt};

use format::Conventional;

/// A matrix.
pub trait Matrix: Into<Conventional<<Self as Matrix>::Element>> + Size {
    /// The element type.
    type Element: Element;

    /// Count nonzero elements.
    fn nonzeros(&self) -> usize;

    /// Create a zero matrix.
    fn zero<S: Size>(S) -> Self;
}

/// A macro for composing matrices in the natural order.
///
/// The data of a generic matrix is conventionally stored in the column-major
/// order; see `format::conventional`. Consequently, the vector
///
/// ```norun
/// vec![
///     1.0, 2.0, 3.0, 4.0,
///     5.0, 6.0, 7.0, 8.0,
/// ]
/// ```
///
/// corresponds to the following matrix with four rows and two columns:
///
/// ```math
/// ┌            ┐
/// │  1.0  5.0  │
/// │  2.0  6.0  │
/// │  3.0  7.0  │
/// │  4.0  8.0  │
/// └            ┘
/// ```
///
/// The macro allows one to write such a matrix in the natural order:
///
/// ```norun
/// matrix![
///     1.0, 5.0;
///     2.0, 6.0;
///     3.0, 7.0;
///     4.0, 8.0;
/// ]
/// ```
#[macro_export]
macro_rules! matrix {
    ($([$tail:expr,];)* -> [$($head:expr,)*]) => (
        vec![$($head,)* $($tail,)*]
    );
    ($([$middle:expr, $($tail:expr,)*];)* -> [$($head:expr,)*]) => (
        matrix!($([$($tail,)*];)* -> [$($head,)* $($middle,)*])
    );
    ($($($item:expr),*;)*) => (
        matrix!($([$($item,)*];)* -> [])
    );
    ($($($item:expr,)*;)*) => (
        matrix!($([$($item,)*];)* -> [])
    );
}

/// An error.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Error(String);

/// A result.
pub type Result<T> = std::result::Result<T, Error>;

macro_rules! raise(
    ($message:expr) => (
        return Err(::Error($message.to_string()));
    );
);

impl fmt::Display for Error {
    #[inline]
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(formatter)
    }
}

impl error::Error for Error {
    #[inline]
    fn description(&self) -> &str {
        &self.0
    }
}

mod element;
mod position;
mod size;

pub use element::Element;
pub use position::Position;
pub use size::Size;

pub mod decomposition;
pub mod format;
pub mod operation;
pub mod prelude;