lineas 0.1.1

A mathematical linear algebra library for Rust
Documentation 
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

use std::fmt::{Debug, Display, Error, Formatter};
use std::ops::{Add, Sub, AddAssign, SubAssign, Mul, MulAssign, Div, DivAssign, Neg};
use conv::{ConvUtil, ValueFrom};
use crate::Complex;

impl<L: Copy + Debug> Complex<L> where L: ValueFrom<isize> {
	/// Make a new complex value from a real value
	///
	/// Generates a complex value with the imaginary part being 0
	pub fn from_real(r: L) -> Self {
		Self {
			real: r,
			imaginary: 0.value_as().unwrap()
		}
	}
	
	/// Make a new complex value from an imaginary value
	///
	/// Generates a complex value with the real part being 0
	pub fn from_imaginary(i: L) -> Self {
		Self {
			real: 0.value_as().unwrap(),
			imaginary: i
		}
	}
	
	/// Make a new complex value from a complex pair
	///
	/// Generates a complex value with the given real and imaginary parts. These must be the same
	/// type
	pub fn from_complex<Q>(r: L, i: Q) -> Self where L: ValueFrom<Q> {
		Self {
			real: r,
			imaginary: i.value_as().unwrap()
		}
	}
	
	/// Return the real part of the complex number
	pub fn real(&self) -> L {
		self.real
	}
	
	/// Return the imaginary part of the complex number
	pub fn imag(&self) -> L {
		self.imaginary
	}
	
	/// Returns the complex conjugate of the complex number
	pub fn conj(&self) -> Self where L: Neg<Output=L> {
		Self {
			real: self.real,
			imaginary: -self.imaginary
		}
	}
	
	/// Changes the data type of the values
	pub fn dtype<Q>(&self) -> Complex<Q> where Q: Copy + Debug + ValueFrom<L> {
		Complex {
			real: self.real.value_as::<Q>().unwrap(),
			imaginary: self.imaginary.value_as::<Q>().unwrap()
		}
	}
}

impl<L: Copy + Debug> ValueFrom<isize> for Complex<L> where L: ValueFrom<isize> {
	type Err = Error;

	fn value_from(src: isize) -> Result<Self, Self::Err> {
		Ok(Complex::from_real(src.value_as().unwrap()))
	}
}

impl<L: Copy + Debug> Add<Complex<L>> for Complex<L> where L: Add<Output=L> {
	type Output = Self;
	
	fn add(self, rhs: Self) -> Self::Output {
		Self {
			real: self.real + rhs.real,
			imaginary: self.imaginary + rhs.imaginary
		}
	}
}

impl<L: Copy + Debug> AddAssign<Complex<L>> for Complex<L> where L: Add<Output=L> {
	fn add_assign(&mut self, rhs: Self) {
		self.real = self.real + rhs.real;
		self.imaginary = self.imaginary + rhs.imaginary;
	}
}

impl<L: Copy + Debug> Sub<Complex<L>> for Complex<L> where L: Sub<Output=L> {
	type Output = Self;
	
	fn sub(self, rhs: Self) -> Self::Output {
		Self {
			real: self.real - rhs.real,
			imaginary: self.imaginary - rhs.imaginary
		}
	}
}

impl<L: Copy + Debug> SubAssign<Complex<L>> for Complex<L> where L: Sub<Output=L> {
	fn sub_assign(&mut self, rhs: Self) {
		self.real = self.real - rhs.real;
		self.imaginary = self.imaginary - rhs.imaginary;
	}
}

impl<L: Copy + Debug> Mul<Complex<L>> for Complex<L> where L: Mul<Output=L> + Sub<Output=L> + Add<Output=L> {
	type Output = Self;
	
	fn mul(self, rhs: Self) -> Self::Output {
		Self {
			real: self.real * rhs.real - self.imaginary * rhs.imaginary,
			imaginary: self.imaginary * rhs.real + self.real * rhs.imaginary
		}
	}
}

impl<L: Copy + Debug> MulAssign<Complex<L>> for Complex<L> where L: Mul<Output=L> + Sub<Output=L> + Add<Output=L> {
	fn mul_assign(&mut self, rhs: Self) {
		let real_temp = self.real * rhs.real - self.imaginary * rhs.imaginary;
		self.imaginary = self.imaginary * rhs.real + self.real * rhs.imaginary;
		self.real = real_temp;
	}
}

impl<L: Copy + Debug> Div<Complex<L>> for Complex<L> where L: Mul<Output=L> + Div<Output=L> + Sub<Output=L> + Add<Output=L> + ValueFrom<isize> + Neg<Output=L> {
	type Output = Self;
	
	/// Divide two complex numbers.
	///
	/// Be aware that this may panic if for `a/b`, `b==0`
	fn div(self, rhs: Complex<L>) -> Self::Output {
		let mut top = self.clone();
		top *= rhs.conj();
		let bottom = rhs.real * rhs.real + rhs.imaginary * rhs.imaginary;
		top.real = top.real / bottom;
		top.imaginary = top.imaginary / bottom;
		top
	}
}

impl<L: Copy + Debug> DivAssign<Complex<L>> for Complex<L> where L: Mul<Output=L> + Div<Output=L> + Sub<Output=L> + Add<Output=L> + ValueFrom<isize> + Neg<Output=L> {
	/// Divide two complex numbers.
	///
	/// Be aware that this may panic if for `a/b`, `b==0`
	fn div_assign(&mut self, rhs: Complex<L>) {
		let mut top = self.clone();
		top *= rhs.conj();
		let bottom = rhs.real * rhs.real + rhs.imaginary * rhs.imaginary;
		top.real = top.real / bottom;
		top.imaginary = top.imaginary / bottom;
		self.real = top.real;
		self.imaginary = top.imaginary;
	}
}

impl<L: Display + Debug + Copy> Display for Complex<L> {
	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
		write!(f, "{}{:+}i", self.real, self.imaginary)
	}
}