hodasemi/cgmath
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Merge pull request #165 from csherratt/master

Browse source 
Cleanup warnings in cgmath.
This commit is contained in:
Dzmitry Malyshau 2015-02-08 13:49:46 -05:00
parent 1e202709b7 33bb8022cb
commit bb5aa209f8
25 changed files with 108 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Cargo.toml
View file

@ -17,4 +17,6 @@ authors = ["Brendan Zabarauskas <bjzaba@yahoo.com.au>",
name = "cgmath"
[dependencies]
rustc-serialize="*"
rustc-serialize="*"
rand_macros="*"
rand="*"

5
benches/construction.rs
View file

@ -13,12 +13,13 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#![feature(test)]
extern crate rand;
extern crate test;
extern crate cgmath;
use std::rand::{IsaacRng, Rng};
use rand::{IsaacRng, Rng};
use std::iter;
use test::Bencher;
use cgmath::{Quaternion, Basis2, Basis3, Vector3, Rotation2, Rotation3, Rad};

6
benches/mat.rs
View file

@ -13,13 +13,13 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#![feature(test)]
extern crate rand;
extern crate test;
extern crate cgmath;
use std::rand::{IsaacRng, Rng};
use rand::{IsaacRng, Rng};
use test::Bencher;
use cgmath::*;

6
benches/quat.rs
View file

@ -13,13 +13,13 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#![feature(test)]
extern crate rand;
extern crate test;
extern crate cgmath;
use std::rand::{IsaacRng, Rng};
use rand::{IsaacRng, Rng};
use test::Bencher;
use cgmath::*;

6
benches/vec.rs
View file

@ -13,13 +13,13 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#![feature(test)]
extern crate rand;
extern crate test;
extern crate cgmath;
use std::rand::{IsaacRng, Rng};
use rand::{IsaacRng, Rng};
use test::Bencher;
use cgmath::*;

4
src/aabb.rs
View file

@ -122,7 +122,7 @@ impl<S: BaseNum> Aabb<S, Vector2<S>, Point2<S>> for Aabb2<S> {
}
}
impl<S: BaseNum> fmt::Show for Aabb2<S> {
impl<S: BaseNum> fmt::Debug for Aabb2<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?} - {:?}]", self.min, self.max)
}
@ -169,7 +169,7 @@ impl<S: BaseNum> Aabb<S, Vector3<S>, Point3<S>> for Aabb3<S> {
}
}
impl<S: BaseNum> fmt::Show for Aabb3<S> {
impl<S: BaseNum> fmt::Debug for Aabb3<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?} - {:?}]", self.min, self.max)
}

6
src/angle.rs
View file

@ -24,10 +24,12 @@ use approx::ApproxEq;
use num::{BaseFloat, One, one, Zero, zero};
/// An angle, in radians
#[derive(Copy, Clone, PartialEq, PartialOrd, Hash, RustcEncodable, RustcDecodable, Rand)]
#[derive_Rand]
#[derive(Copy, Clone, PartialEq, PartialOrd, Hash, RustcEncodable, RustcDecodable)]
pub struct Rad<S> { pub s: S }
/// An angle, in degrees
#[derive(Copy, Clone, PartialEq, PartialOrd, Hash, RustcEncodable, RustcDecodable, Rand)]
#[derive_Rand]
#[derive(Copy, Clone, PartialEq, PartialOrd, Hash, RustcEncodable, RustcDecodable)]
pub struct Deg<S> { pub s: S }
/// Create a new angle, in radians

5
src/cgmath.rs
View file

@ -15,7 +15,7 @@
#![crate_type = "rlib"]
#![crate_type = "dylib"]
#![feature(old_impl_check)]
#![feature(old_impl_check, plugin, core, std_misc)]
//! Computer graphics-centric math.
//!
@ -32,6 +32,9 @@
//! These are provided for convenience.
extern crate "rustc-serialize" as rustc_serialize;
extern crate rand;
#[plugin]
extern crate rand_macros;
// Re-exports

15
src/matrix.rs
View file

@ -30,15 +30,18 @@ use vector::{Vector, EuclideanVector};
use vector::{Vector2, Vector3, Vector4};
/// A 2 x 2, column major matrix
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Rand)]
#[derive_Rand]
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
pub struct Matrix2<S> { pub x: Vector2<S>, pub y: Vector2<S> }
/// A 3 x 3, column major matrix
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Rand)]
#[derive_Rand]
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
pub struct Matrix3<S> { pub x: Vector3<S>, pub y: Vector3<S>, pub z: Vector3<S> }
/// A 4 x 4, column major matrix
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Rand)]
#[derive_Rand]
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
pub struct Matrix4<S> { pub x: Vector4<S>, pub y: Vector4<S>, pub z: Vector4<S>, pub w: Vector4<S> }
@ -1375,7 +1378,7 @@ impl<S: BaseFloat + 'static> ToQuaternion<S> for Matrix3<S> {
}
}
impl<S: BaseNum> fmt::Show for Matrix2<S> {
impl<S: BaseNum> fmt::Debug for Matrix2<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[[{:?}, {:?}], [{:?}, {:?}]]",
self[0][0], self[0][1],
@ -1383,7 +1386,7 @@ impl<S: BaseNum> fmt::Show for Matrix2<S> {
}
}
impl<S: BaseNum> fmt::Show for Matrix3<S> {
impl<S: BaseNum> fmt::Debug for Matrix3<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[[{:?}, {:?}, {:?}], [{:?}, {:?}, {:?}], [{:?}, {:?}, {:?}]]",
self[0][0], self[0][1], self[0][2],
@ -1392,7 +1395,7 @@ impl<S: BaseNum> fmt::Show for Matrix3<S> {
}
}
impl<S: BaseNum> fmt::Show for Matrix4<S> {
impl<S: BaseNum> fmt::Debug for Matrix4<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[[{:?}, {:?}, {:?}, {:?}], [{:?}, {:?}, {:?}, {:?}], [{:?}, {:?}, {:?}, {:?}], [{:?}, {:?}, {:?}, {:?}]]",
self[0][0], self[0][1], self[0][2], self[0][3],

2
src/plane.rs
View file

@ -129,7 +129,7 @@ ApproxEq<S> for Plane<S> {
}
}
impl<S: BaseFloat> fmt::Show for Plane<S> {
impl<S: BaseFloat> fmt::Debug for Plane<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?}x + {:?}y + {:?}z - {:?} = 0",
self.n.x, self.n.y, self.n.z, self.d)

4
src/point.rs
View file

@ -428,13 +428,13 @@ impl<S: BaseFloat> ApproxEq<S> for Point3<S> {
}
}
impl<S: BaseNum> fmt::Show for Point2<S> {
impl<S: BaseNum> fmt::Debug for Point2<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?}, {:?}]", self.x, self.y)
}
}
impl<S: BaseNum> fmt::Show for Point3<S> {
impl<S: BaseNum> fmt::Debug for Point3<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?}, {:?}, {:?}]", self.x, self.y, self.z)
}

5
src/quaternion.rs
View file

@ -30,7 +30,8 @@ use vector::{Vector3, Vector, EuclideanVector};
/// A [quaternion](https://en.wikipedia.org/wiki/Quaternion) in scalar/vector
/// form.
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, Rand)]
#[derive_Rand]
#[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable)]
pub struct Quaternion<S> { pub s: S, pub v: Vector3<S> }
/// Represents types which can be expressed as a quaternion.
@ -368,7 +369,7 @@ impl<S: BaseFloat> Neg for Quaternion<S> {
}
}
impl<S: BaseFloat> fmt::Show for Quaternion<S> {
impl<S: BaseFloat> fmt::Debug for Quaternion<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?} + {:?}i + {:?}j + {:?}k",
self.s,

2
src/transform.rs
View file

@ -151,7 +151,7 @@ impl<S: BaseFloat + 'static, R: Rotation3<S>> ToMatrix4<S> for Decomposed<S, Vec
impl<S: BaseFloat, R: Rotation3<S>> Transform3<S> for Decomposed<S,Vector3<S>,R> where S: 'static {}
impl<S: BaseFloat, R: fmt::Show + Rotation3<S>> fmt::Show for Decomposed<S,Vector3<S>,R> {
impl<S: BaseFloat, R: fmt::Debug + Rotation3<S>> fmt::Debug for Decomposed<S,Vector3<S>,R> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "(scale({:?}), rot({:?}), disp{:?})",
self.scale, self.rot, self.disp)

9
src/vector.rs
View file

@ -178,7 +178,8 @@ pub trait Vector<S: BaseNum>: Array1<S> + Zero + One + Neg<Output=Self> {
// Utility macro for generating associated functions for the vectors
macro_rules! vec(
($Self:ident <$S:ident> { $($field:ident),+ }, $n:expr, $constructor:ident) => (
#[derive(PartialEq, Eq, Copy, Clone, Hash, RustcEncodable, RustcDecodable, Rand)]
#[derive_Rand]
#[derive(PartialEq, Eq, Copy, Clone, Hash, RustcEncodable, RustcDecodable)]
pub struct $Self<S> { $(pub $field: S),+ }
impl<$S> $Self<$S> {
@ -557,19 +558,19 @@ impl<S: BaseFloat> EuclideanVector<S> for Vector4<S> {
}
}
impl<S: BaseNum> fmt::Show for Vector2<S> {
impl<S: BaseNum> fmt::Debug for Vector2<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?}, {:?}]", self.x, self.y)
}
}
impl<S: BaseNum> fmt::Show for Vector3<S> {
impl<S: BaseNum> fmt::Debug for Vector3<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?}, {:?}, {:?}]", self.x, self.y, self.z)
}
}
impl<S: BaseNum> fmt::Show for Vector4<S> {
impl<S: BaseNum> fmt::Debug for Vector4<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "[{:?}, {:?}, {:?}, {:?}]", self.x, self.y, self.z, self.w)
}

68
tests/aabb.rs
View file

@ -13,8 +13,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
extern crate cgmath;
use cgmath::{Aabb, Aabb2, Aabb3};
@ -24,46 +22,46 @@ use cgmath::{Ray, Intersect};
#[test]
fn test_aabb() {
let aabb = Aabb2::new(Point2::new(-20i, 30i), Point2::new(10i, -10i));
assert_eq!(aabb.min(), &Point2::new(-20i, -10i));
assert_eq!(aabb.max(), &Point2::new(10i, 30i));
assert_eq!(aabb.dim(), Vector2::new(30i, 40i));
assert_eq!(aabb.volume(), 30i * 40i);
assert_eq!(aabb.center(), Point2::new(-5i, 10i));
let aabb = Aabb2::new(Point2::new(-20is, 30is), Point2::new(10is, -10is));
assert_eq!(aabb.min(), &Point2::new(-20is, -10is));
assert_eq!(aabb.max(), &Point2::new(10is, 30is));
assert_eq!(aabb.dim(), Vector2::new(30is, 40is));
assert_eq!(aabb.volume(), 30is * 40is);
assert_eq!(aabb.center(), Point2::new(-5is, 10is));
assert!(aabb.contains(&Point2::new(0i, 0i)));
assert!(!aabb.contains(&Point2::new(-50i, -50i)));
assert!(!aabb.contains(&Point2::new(50i, 50i)));
assert!(aabb.contains(&Point2::new(0is, 0is)));
assert!(!aabb.contains(&Point2::new(-50is, -50is)));
assert!(!aabb.contains(&Point2::new(50is, 50is)));
assert_eq!(aabb.grow(&Point2::new(0i, 0i)), aabb);
assert_eq!(aabb.grow(&Point2::new(100i, 100i)),
Aabb2::new(Point2::new(-20i, -10i), Point2::new(100i, 100i)));
assert_eq!(aabb.grow(&Point2::new(-100i, -100i)),
Aabb2::new(Point2::new(-100i, -100i), Point2::new(10i, 30i)));
assert_eq!(aabb.grow(&Point2::new(0is, 0is)), aabb);
assert_eq!(aabb.grow(&Point2::new(100is, 100is)),
Aabb2::new(Point2::new(-20is, -10is), Point2::new(100is, 100is)));
assert_eq!(aabb.grow(&Point2::new(-100is, -100is)),
Aabb2::new(Point2::new(-100is, -100is), Point2::new(10is, 30is)));
let aabb = Aabb3::new(Point3::new(-20i, 30i, 5i), Point3::new(10i, -10i, -5i));
assert_eq!(aabb.min(), &Point3::new(-20i, -10i, -5i));
assert_eq!(aabb.max(), &Point3::new(10i, 30i, 5i));
assert_eq!(aabb.dim(), Vector3::new(30i, 40i, 10i));
assert_eq!(aabb.volume(), 30i * 40i * 10i);
assert_eq!(aabb.center(), Point3::new(-5i, 10i, 0i));
let aabb = Aabb3::new(Point3::new(-20is, 30is, 5is), Point3::new(10is, -10is, -5is));
assert_eq!(aabb.min(), &Point3::new(-20is, -10is, -5is));
assert_eq!(aabb.max(), &Point3::new(10is, 30is, 5is));
assert_eq!(aabb.dim(), Vector3::new(30is, 40is, 10is));
assert_eq!(aabb.volume(), 30is * 40is * 10is);
assert_eq!(aabb.center(), Point3::new(-5is, 10is, 0is));
assert!(aabb.contains(&Point3::new(0i, 0i, 0i)));
assert!(!aabb.contains(&Point3::new(-100i, 0i, 0i)));
assert!(!aabb.contains(&Point3::new(100i, 0i, 0i)));
assert!(aabb.contains(&Point3::new(9i, 29i, -1i)));
assert!(!aabb.contains(&Point3::new(10i, 30i, 5i)));
assert!(aabb.contains(&Point3::new(-20i, -10i, -5i)));
assert!(!aabb.contains(&Point3::new(-21i, -11i, -6i)));
assert!(aabb.contains(&Point3::new(0is, 0is, 0is)));
assert!(!aabb.contains(&Point3::new(-100is, 0is, 0is)));
assert!(!aabb.contains(&Point3::new(100is, 0is, 0is)));
assert!(aabb.contains(&Point3::new(9is, 29is, -1is)));
assert!(!aabb.contains(&Point3::new(10is, 30is, 5is)));
assert!(aabb.contains(&Point3::new(-20is, -10is, -5is)));
assert!(!aabb.contains(&Point3::new(-21is, -11is, -6is)));
assert_eq!(aabb.add_v(&Vector3::new(1i, 2i, 3i)),
Aabb3::new(Point3::new(-19i, 32i, 8i), Point3::new(11i, -8i, -2i)));
assert_eq!(aabb.add_v(&Vector3::new(1is, 2is, 3is)),
Aabb3::new(Point3::new(-19is, 32is, 8is), Point3::new(11is, -8is, -2is)));
assert_eq!(aabb.mul_s(2i),
Aabb3::new(Point3::new(-40i, -20i, -10i), Point3::new(20i, 60i, 10i)));
assert_eq!(aabb.mul_s(2is),
Aabb3::new(Point3::new(-40is, -20is, -10is), Point3::new(20is, 60is, 10is)));
assert_eq!(aabb.mul_v(&Vector3::new(1i, 2i, 3i)),
Aabb3::new(Point3::new(-20i, -20i, -15i), Point3::new(10i, 60i, 15i)));
assert_eq!(aabb.mul_v(&Vector3::new(1is, 2is, 3is)),
Aabb3::new(Point3::new(-20is, -20is, -15is), Point3::new(10is, 60is, 15is)));
}
#[test]

2
tests/angle.rs
View file

@ -13,8 +13,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
extern crate cgmath;
use cgmath::{Angle, Rad, Deg, rad, deg};

1
tests/approx.rs
View file

@ -13,7 +13,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#[macro_use]
extern crate cgmath;

1
tests/line.rs
View file

@ -14,7 +14,6 @@
// limitations under the License.
extern crate cgmath;
use cgmath::*;

1
tests/matrix.rs
View file

@ -13,6 +13,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#![feature(core)]
extern crate cgmath;

1
tests/plane.rs
View file

@ -14,7 +14,6 @@
// limitations under the License.
extern crate cgmath;
use cgmath::*;

1
tests/point.rs
View file

@ -14,7 +14,6 @@
// limitations under the License.
extern crate cgmath;
use cgmath::Point3;

1
tests/quaternion.rs
View file

@ -14,7 +14,6 @@
// limitations under the License.
extern crate cgmath;
use cgmath::{ToMatrix4, ToMatrix3};

1
tests/sphere.rs
View file

@ -14,7 +14,6 @@
// limitations under the License.
extern crate cgmath;
use cgmath::*;

1
tests/transform.rs
View file

@ -14,7 +14,6 @@
// limitations under the License.
extern crate cgmath;
use cgmath::*;

54
tests/vector.rs
View file

@ -13,6 +13,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#![feature(core)]
#[macro_use]
extern crate cgmath;
@ -29,23 +31,23 @@ fn test_constructor() {
#[test]
fn test_from_value() {
assert_eq!(Vector2::from_value(102i), Vector2::new(102i, 102i));
assert_eq!(Vector3::from_value(22i), Vector3::new(22i, 22i, 22i));
assert_eq!(Vector2::from_value(102is), Vector2::new(102is, 102is));
assert_eq!(Vector3::from_value(22is), Vector3::new(22is, 22is, 22is));
assert_eq!(Vector4::from_value(76.5f64), Vector4::new(76.5f64, 76.5f64, 76.5f64, 76.5f64));
}
#[test]
fn test_dot() {
assert_eq!(Vector2::new(1i, 2i).dot(&Vector2::new(3i, 4i)), 11i);
assert_eq!(Vector3::new(1i, 2i, 3i).dot(&Vector3::new(4i, 5i, 6i)), 32i);
assert_eq!(Vector4::new(1i, 2i, 3i, 4i).dot(&Vector4::new(5i, 6i, 7i, 8i)), 70i);
assert_eq!(Vector2::new(1is, 2is).dot(&Vector2::new(3is, 4is)), 11is);
assert_eq!(Vector3::new(1is, 2is, 3is).dot(&Vector3::new(4is, 5is, 6is)), 32is);
assert_eq!(Vector4::new(1is, 2is, 3is, 4is).dot(&Vector4::new(5is, 6is, 7is, 8is)), 70is);
}
#[test]
fn test_comp_add() {
assert_eq!(Vector2::new(1i, 2i).comp_add(), 3i);
assert_eq!(Vector3::new(1i, 2i, 3i).comp_add(), 6i);
assert_eq!(Vector4::new(1i, 2i, 3i, 4i).comp_add(), 10i);
assert_eq!(Vector2::new(1is, 2is).comp_add(), 3is);
assert_eq!(Vector3::new(1is, 2is, 3is).comp_add(), 6is);
assert_eq!(Vector4::new(1is, 2is, 3is, 4is).comp_add(), 10is);
assert_eq!(Vector2::new(3.0f64, 4.0f64).comp_add(), 7.0f64);
assert_eq!(Vector3::new(4.0f64, 5.0f64, 6.0f64).comp_add(), 15.0f64);
@ -54,9 +56,9 @@ fn test_comp_add() {
#[test]
fn test_comp_mul() {
assert_eq!(Vector2::new(1i, 2i).comp_mul(), 2i);
assert_eq!(Vector3::new(1i, 2i, 3i).comp_mul(), 6i);
assert_eq!(Vector4::new(1i, 2i, 3i, 4i).comp_mul(), 24i);
assert_eq!(Vector2::new(1is, 2is).comp_mul(), 2is);
assert_eq!(Vector3::new(1is, 2is, 3is).comp_mul(), 6is);
assert_eq!(Vector4::new(1is, 2is, 3is, 4is).comp_mul(), 24is);
assert_eq!(Vector2::new(3.0f64, 4.0f64).comp_mul(), 12.0f64);
assert_eq!(Vector3::new(4.0f64, 5.0f64, 6.0f64).comp_mul(), 120.0f64);
@ -65,9 +67,9 @@ fn test_comp_mul() {
#[test]
fn test_comp_min() {
assert_eq!(Vector2::new(1i, 2i).comp_min(), 1i);
assert_eq!(Vector3::new(1i, 2i, 3i).comp_min(), 1i);
assert_eq!(Vector4::new(1i, 2i, 3i, 4i).comp_min(), 1i);
assert_eq!(Vector2::new(1is, 2is).comp_min(), 1is);
assert_eq!(Vector3::new(1is, 2is, 3is).comp_min(), 1is);
assert_eq!(Vector4::new(1is, 2is, 3is, 4is).comp_min(), 1is);
assert_eq!(Vector2::new(3.0f64, 4.0f64).comp_min(), 3.0f64);
assert_eq!(Vector3::new(4.0f64, 5.0f64, 6.0f64).comp_min(), 4.0f64);
@ -76,9 +78,9 @@ fn test_comp_min() {
#[test]
fn test_comp_max() {
assert_eq!(Vector2::new(1i, 2i).comp_max(), 2i);
assert_eq!(Vector3::new(1i, 2i, 3i).comp_max(), 3i);
assert_eq!(Vector4::new(1i, 2i, 3i, 4i).comp_max(), 4i);
assert_eq!(Vector2::new(1is, 2is).comp_max(), 2is);
assert_eq!(Vector3::new(1is, 2is, 3is).comp_max(), 3is);
assert_eq!(Vector4::new(1is, 2is, 3is, 4is).comp_max(), 4is);
assert_eq!(Vector2::new(3.0f64, 4.0f64).comp_max(), 4.0f64);
assert_eq!(Vector3::new(4.0f64, 5.0f64, 6.0f64).comp_max(), 6.0f64);
@ -87,9 +89,9 @@ fn test_comp_max() {
#[test]
fn test_cross() {
let a = Vector3::new(1i, 2i, 3i);
let b = Vector3::new(4i, 5i, 6i);
let r = Vector3::new(-3i, 6i, -3i);
let a = Vector3::new(1is, 2is, 3is);
let b = Vector3::new(4is, 5is, 6is);
let r = Vector3::new(-3is, 6is, -3is);
assert_eq!(a.cross(&b), r);
let mut a = a;
@ -110,8 +112,8 @@ mod test_length {
#[test]
fn test_vector2(){
let (a, a_res) = (Vector2::new(3.0f64, 4.0f64), 5.0f64); // (3i, 4i, 5i) Pythagorean triple
let (b, b_res) = (Vector2::new(5.0f64, 12.0f64), 13.0f64); // (5i, 12i, 13i) Pythagorean triple
let (a, a_res) = (Vector2::new(3.0f64, 4.0f64), 5.0f64); // (3is, 4is, 5is) Pythagorean triple
let (b, b_res) = (Vector2::new(5.0f64, 12.0f64), 13.0f64); // (5is, 12is, 13is) Pythagorean triple
assert_eq!(a.length2(), a_res * a_res);
assert_eq!(b.length2(), b_res * b_res);
@ -122,8 +124,8 @@ mod test_length {
#[test]
fn test_vector3(){
let (a, a_res) = (Vector3::new(2.0f64, 3.0f64, 6.0f64), 7.0f64); // (2i, 3i, 6i, 7i) Pythagorean quadruple
let (b, b_res) = (Vector3::new(1.0f64, 4.0f64, 8.0f64), 9.0f64); // (1i, 4i, 8i, 9i) Pythagorean quadruple
let (a, a_res) = (Vector3::new(2.0f64, 3.0f64, 6.0f64), 7.0f64); // (2is, 3is, 6is, 7is) Pythagorean quadruple
let (b, b_res) = (Vector3::new(1.0f64, 4.0f64, 8.0f64), 9.0f64); // (1is, 4is, 8is, 9is) Pythagorean quadruple
assert_eq!(a.length2(), a_res * a_res);
assert_eq!(b.length2(), b_res * b_res);
@ -134,8 +136,8 @@ mod test_length {
#[test]
fn test_vector4(){
let (a, a_res) = (Vector4::new(1.0f64, 2.0f64, 4.0f64, 10.0f64), 11.0f64); // (1i, 2i, 4i, 10i, 11i) Pythagorean quintuple
let (b, b_res) = (Vector4::new(1.0f64, 2.0f64, 8.0f64, 10.0f64), 13.0f64); // (1i, 2i, 8i, 10i, 13i) Pythagorean quintuple
let (a, a_res) = (Vector4::new(1.0f64, 2.0f64, 4.0f64, 10.0f64), 11.0f64); // (1is, 2is, 4is, 10is, 11is) Pythagorean quintuple
let (b, b_res) = (Vector4::new(1.0f64, 2.0f64, 8.0f64, 10.0f64), 13.0f64); // (1is, 2is, 8is, 10is, 13is) Pythagorean quintuple
assert_eq!(a.length2(), a_res * a_res);
assert_eq!(b.length2(), b_res * b_res);