From dfe14b3b5a043a2d090839f3bacd80f64e577145 Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 01/11] Use https in doc link --- Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 850fd3f7e..946c9337c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ authors = ["bluss"] license = "MIT/Apache-2.0" repository = "https://github.com/bluss/rust-ndarray" -documentation = "http://bluss.github.io/rust-ndarray/" +documentation = "https://bluss.github.io/rust-ndarray/" description = "An N-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting." From ba75c4c9c264649d370a1ec0be397e0e2731d663 Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 02/11] Drop rustc_version and the has_deprecated thing from the build script --- Cargo.toml | 3 --- build.rs | 23 +---------------------- 2 files changed, 1 insertion(+), 25 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 946c9337c..fbbd1d633 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -19,9 +19,6 @@ name = "ndarray" bench = false test = false -[build-dependencies] -rustc_version = "0.1.3" - [dependencies.num-traits] version = "0.1.32" default-features = false diff --git a/build.rs b/build.rs index e9e7a215d..385a423f2 100644 --- a/build.rs +++ b/build.rs @@ -1,30 +1,9 @@ /// -/// This build script Checks if we can use #[deprecated] +/// This build script emits the openblas linking directive if requested /// -extern crate rustc_version; - -use rustc_version::Channel; - -const DEPRECATED_CFG: &'static str = "has_deprecated"; - fn main() { - let version = rustc_version::version_meta(); - println!("cargo:rerun-if-changed=build.rs"); - if version.channel == Channel::Nightly || version.channel == Channel::Beta { - if let Some(ref date) = version.commit_date { - // parse year, month, day - let ndate = date.splitn(3, "-") - .map(str::parse) - .collect::, _>>().unwrap(); - - // deprecated is stable from nightly 04-12 - if ndate >= vec![2016, 04, 12] { - println!("cargo:rustc-cfg={}", DEPRECATED_CFG); - } - } - } if cfg!(feature = "blas-openblas-sys") { println!("cargo:rustc-link-lib={}=openblas", "dylib"); } From b478e0403be5c0f98f62f9159ef266837ea3c60b Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 03/11] Remove deprecated constructor methods Use zeros, from_elem, from_shape_vec, or from_shape_vec_unchecked instead. --- src/arraytraits.rs | 2 +- src/impl_constructors.rs | 65 ++-------------------------------------- 2 files changed, 3 insertions(+), 64 deletions(-) diff --git a/src/arraytraits.rs b/src/arraytraits.rs index 1c76c2a0f..b357765ca 100644 --- a/src/arraytraits.rs +++ b/src/arraytraits.rs @@ -271,7 +271,7 @@ impl Decodable for ArrayBase }) })); unsafe { - Ok(ArrayBase::from_vec_dim_unchecked(dim, elements)) + Ok(ArrayBase::from_shape_vec_unchecked(dim, elements)) } }) } diff --git a/src/impl_constructors.rs b/src/impl_constructors.rs index 142027257..1da1ba0ff 100644 --- a/src/impl_constructors.rs +++ b/src/impl_constructors.rs @@ -10,8 +10,6 @@ //! //! -#![allow(deprecated)] // from_shape_vec - use libnum::{Zero, One, Float}; use imp_prelude::*; @@ -234,63 +232,7 @@ impl ArrayBase Self::from_vec_dim_stride_unchecked(shape.dim, shape.strides, v) } - #[cfg_attr(has_deprecated, deprecated(note="Use from_elem instead."))] - /// ***Deprecated: Use from_elem instead*** - pub fn from_elem_f(dim: D, elem: A) -> ArrayBase - where A: Clone - { - Self::from_elem(dim.f(), elem) - } - - #[cfg_attr(has_deprecated, deprecated(note="Use zeros instead."))] - /// ***Deprecated: Use zeros instead*** - pub fn zeros_f(dim: D) -> ArrayBase - where A: Clone + Zero - { - Self::from_elem_f(dim, A::zero()) - } - - #[cfg_attr(has_deprecated, deprecated(note="Use from_shape_vec instead."))] - /// ***Deprecated: Use from_shape_vec instead*** - pub fn from_vec_dim(dim: D, v: Vec) -> Result, ShapeError> { - if dim.size_checked() != Some(v.len()) { - return Err(error::incompatible_shapes(&v.len(), &dim)); - } - unsafe { Ok(Self::from_vec_dim_unchecked(dim, v)) } - } - - #[cfg_attr(has_deprecated, deprecated(note="Use from_shape_vec instead."))] - /// ***Deprecated: Use from_shape_vec instead*** - pub fn from_vec_dim_f(dim: D, v: Vec) -> Result, ShapeError> { - if dim.size_checked() != Some(v.len()) { - return Err(error::incompatible_shapes(&v.len(), &dim)); - } - unsafe { Ok(Self::from_vec_dim_unchecked_f(dim, v)) } - } - - #[cfg_attr(has_deprecated, deprecated(note="Use from_shape_vec_unchecked instead."))] - /// ***Deprecated: Use from_shape_vec_unchecked instead*** - pub unsafe fn from_vec_dim_unchecked(dim: D, mut v: Vec) -> ArrayBase { - debug_assert!(dim.size_checked() == Some(v.len())); - ArrayBase { - ptr: v.as_mut_ptr(), - data: DataOwned::new(v), - strides: dim.default_strides(), - dim: dim, - } - } - - #[cfg_attr(has_deprecated, deprecated(note="Use from_shape_vec_unchecked instead."))] - /// ***Deprecated: Use from_shape_vec_unchecked instead*** - pub unsafe fn from_vec_dim_unchecked_f(dim: D, v: Vec) -> ArrayBase { - debug_assert!(dim.size_checked() == Some(v.len())); - let strides = dim.fortran_strides(); - Self::from_vec_dim_stride_unchecked(dim, strides, v) - } - - #[cfg_attr(has_deprecated, deprecated(note="Use from_shape_vec instead."))] - /// ***Deprecated: Use from_shape_vec instead*** - pub fn from_vec_dim_stride(dim: D, strides: D, v: Vec) + fn from_vec_dim_stride(dim: D, strides: D, v: Vec) -> Result, ShapeError> { dimension::can_index_slice(&v, &dim, &strides).map(|_| { @@ -300,10 +242,7 @@ impl ArrayBase }) } - #[cfg_attr(has_deprecated, deprecated(note="Use from_shape_vec_unchecked instead."))] - /// ***Deprecated: Use from_shape_vec_unchecked instead*** - /// - pub unsafe fn from_vec_dim_stride_unchecked(dim: D, strides: D, mut v: Vec) + unsafe fn from_vec_dim_stride_unchecked(dim: D, strides: D, mut v: Vec) -> ArrayBase { // debug check for issues that indicates wrong use of this constructor From 817561f60ed00d9cbd6d6573b84a26c04d9ae4f4 Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 04/11] Remove deprecated .iadd(), .iadd_scalar() etc methods Use += and so on instead. --- src/impl_ops_inplace.rs | 99 ----------------------------------------- src/lib.rs | 2 - 2 files changed, 101 deletions(-) delete mode 100644 src/impl_ops_inplace.rs diff --git a/src/impl_ops_inplace.rs b/src/impl_ops_inplace.rs deleted file mode 100644 index 54757bfe8..000000000 --- a/src/impl_ops_inplace.rs +++ /dev/null @@ -1,99 +0,0 @@ -// Copyright 2014-2016 bluss and ndarray developers. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -use std::ops::{ - Add, Sub, Mul, Div, Rem, Neg, Not, Shr, Shl, - BitAnd, - BitOr, - BitXor, -}; -use imp_prelude::*; -// array OPERATORS - -macro_rules! as_expr( - ($e:expr) => ($e) -); - -macro_rules! impl_binary_op_inplace( - ($trt:ident, $operator:tt, $mth:ident, $imethod:ident, $imth_scalar:ident, $doc:expr) => ( - #[cfg_attr(has_deprecated, deprecated(note="Use augmented assignment operator instead"))] - /// Perform elementwise - #[doc=$doc] - /// between `self` and `rhs`, - /// *in place*. - /// - /// If their shapes disagree, `rhs` is broadcast to the shape of `self`. - /// - /// **Panics** if broadcasting isn’t possible. - pub fn $imethod (&mut self, rhs: &ArrayBase) - where A: Clone + $trt, - S2: Data, - { - self.zip_mut_with(rhs, |x, y| { - *x = as_expr!(x.clone() $operator y.clone()); - }); - } - - #[cfg_attr(has_deprecated, deprecated(note="Use augmented assignment operator instead"))] - /// Perform elementwise - #[doc=$doc] - /// between `self` and the scalar `x`, - /// *in place*. - pub fn $imth_scalar (&mut self, x: &A) - where A: Clone + $trt, - { - self.unordered_foreach_mut(move |elt| { - *elt = as_expr!(elt.clone() $operator x.clone()); - }); - } - ); -); - -/// In-place arithmetic operations. -/// -/// ***Note: These will be deprecated in favour of overloaded `@=` operators -/// when Rust 1.8 is released.*** -impl ArrayBase - where S: DataMut, - D: Dimension, -{ - - -impl_binary_op_inplace!(Add, +, add, iadd, iadd_scalar, "addition"); -impl_binary_op_inplace!(Sub, -, sub, isub, isub_scalar, "subtraction"); -impl_binary_op_inplace!(Mul, *, mul, imul, imul_scalar, "multiplication"); -impl_binary_op_inplace!(Div, /, div, idiv, idiv_scalar, "division"); -impl_binary_op_inplace!(Rem, %, rem, irem, irem_scalar, "remainder"); -impl_binary_op_inplace!(BitAnd, &, bitand, ibitand, ibitand_scalar, "bit and"); -impl_binary_op_inplace!(BitOr, |, bitor, ibitor, ibitor_scalar, "bit or"); -impl_binary_op_inplace!(BitXor, ^, bitxor, ibitxor, ibitxor_scalar, "bit xor"); -impl_binary_op_inplace!(Shl, <<, shl, ishl, ishl_scalar, "left shift"); -impl_binary_op_inplace!(Shr, >>, shr, ishr, ishr_scalar, "right shift"); - - #[cfg_attr(has_deprecated, deprecated(note="Use augmented assignment operator instead"))] - /// Perform an elementwise negation of `self`, *in place*. - pub fn ineg(&mut self) - where A: Clone + Neg, - { - self.unordered_foreach_mut(|elt| { - *elt = -elt.clone(); - }); - } - - #[cfg_attr(has_deprecated, deprecated(note="Use augmented assignment operator instead"))] - /// Perform an elementwise unary not of `self`, *in place*. - pub fn inot(&mut self) - where A: Clone + Not, - { - self.unordered_foreach_mut(|elt| { - *elt = !elt.clone(); - }); - } - -} - diff --git a/src/lib.rs b/src/lib.rs index ff32bb3b9..3404d2a9f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -519,8 +519,6 @@ mod numeric; pub mod linalg; -mod impl_ops_inplace; - mod impl_ops; pub use impl_ops::ScalarOperand; From bb69ef9ceaa7818ab90165610eb1446c5ee166f9 Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 05/11] Remove deprecated from_slice_dim_stride methods for ArrayViews Use from_shape instead --- src/impl_views.rs | 24 ------------------------ 1 file changed, 24 deletions(-) diff --git a/src/impl_views.rs b/src/impl_views.rs index 209603255..5b6e4dd37 100644 --- a/src/impl_views.rs +++ b/src/impl_views.rs @@ -59,18 +59,6 @@ impl<'a, A, D> ArrayBase, D> }) } - #[cfg_attr(has_deprecated, deprecated(note="Use from_shape instead."))] - /// ***Deprecated: Use from_shape instead*** - pub fn from_slice_dim_stride(dim: D, strides: D, xs: &'a [A]) - -> Result - { - dimension::can_index_slice(xs, &dim, &strides).map(|_| { - unsafe { - Self::new_(xs.as_ptr(), dim, strides) - } - }) - } - /// Split the array along `axis` and return one view strictly before the /// split and one view after the split. /// @@ -160,18 +148,6 @@ impl<'a, A, D> ArrayBase, D> }) } - #[cfg_attr(has_deprecated, deprecated(note="Use from_shape instead."))] - /// ***Deprecated: Use from_shape instead*** - pub fn from_slice_dim_stride(dim: D, strides: D, xs: &'a mut [A]) - -> Result - { - dimension::can_index_slice(xs, &dim, &strides).map(|_| { - unsafe { - Self::new_(xs.as_mut_ptr(), dim, strides) - } - }) - } - /// Split the array along `axis` and return one mutable view strictly /// before the split and one mutable view after the split. /// From 98d2dc9127d1f0ac2844ffb79ac5ff2eee8fe88d Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 06/11] Remove deprecated .mat_mul(), .mat_mul_col() Use .dot() instead. --- src/lib.rs | 4 ++-- src/linalg/impl_linalg.rs | 16 ---------------- 2 files changed, 2 insertions(+), 18 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 3404d2a9f..6609703e3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -576,7 +576,7 @@ impl<'a, A, D> ArrayBase, D> /// Return an outer iterator for this view. #[doc(hidden)] // not official - #[cfg_attr(has_deprecated, deprecated(note="This method will be replaced."))] + #[deprecated(note="This method will be replaced.")] pub fn into_outer_iter(self) -> AxisIter<'a, A, D::Smaller> where D: RemoveAxis, { @@ -640,7 +640,7 @@ impl<'a, A, D> ArrayBase, D> /// Return an outer iterator for this view. #[doc(hidden)] // not official - #[cfg_attr(has_deprecated, deprecated(note="This method will be replaced."))] + #[deprecated(note="This method will be replaced.")] pub fn into_outer_iter(self) -> AxisIterMut<'a, A, D::Smaller> where D: RemoveAxis, { diff --git a/src/linalg/impl_linalg.rs b/src/linalg/impl_linalg.rs index 6776d5d50..08ddcdd56 100644 --- a/src/linalg/impl_linalg.rs +++ b/src/linalg/impl_linalg.rs @@ -187,22 +187,6 @@ impl ArrayBase { Dot::dot(self, rhs) } - - #[cfg_attr(has_deprecated, deprecated(note="Use .dot() instead."))] - pub fn mat_mul(&self, rhs: &ArrayBase) -> OwnedArray - where A: LinalgScalar, - S2: Data, - { - self.dot(rhs) - } - - #[cfg_attr(has_deprecated, deprecated(note="Use .dot() instead."))] - pub fn mat_mul_col(&self, rhs: &ArrayBase) -> OwnedArray - where A: LinalgScalar, - S2: Data, - { - self.dot(rhs) - } } impl Dot> for ArrayBase From 04bedd1cc99dc0d1dbf42e774cfc1900aaf9439c Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 07/11] rand: Update to use ndarray 0.6 --- ndarray-rand/Cargo.toml | 2 +- ndarray-rand/src/lib.rs | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/ndarray-rand/Cargo.toml b/ndarray-rand/Cargo.toml index 8d1012d48..b1c0dca89 100644 --- a/ndarray-rand/Cargo.toml +++ b/ndarray-rand/Cargo.toml @@ -13,4 +13,4 @@ keywords = ["multidimensional", "matrix", "rand", "ndarray"] [dependencies] rand = "0.3" -ndarray = { version = ">= 0.4.9, < 0.6", path = ".." } +ndarray = { version = "0.6", path = ".." } diff --git a/ndarray-rand/src/lib.rs b/ndarray-rand/src/lib.rs index 4920956a4..89cc409d0 100644 --- a/ndarray-rand/src/lib.rs +++ b/ndarray-rand/src/lib.rs @@ -75,13 +75,12 @@ impl RandomExt for ArrayBase Self::random_using(dim, dist, &mut rand::weak_rng()) } - #[allow(deprecated)] // from_vec_dim fn random_using(dim: D, dist: IdS, rng: &mut R) -> ArrayBase where IdS: IndependentSample, R: Rng { let elements = Vec::from_iter((0..dim.size()).map(move |_| dist.ind_sample(rng))); - Self::from_vec_dim(dim, elements).unwrap() + Self::from_shape_vec(dim, elements).unwrap() } } From 49b14c05ee569020e03a89fc8de03d8c91173f67 Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 08/11] Skip ndarray-rblas in docs --- docgen/mkdocs.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docgen/mkdocs.py b/docgen/mkdocs.py index 4ede608c0..a95f62137 100755 --- a/docgen/mkdocs.py +++ b/docgen/mkdocs.py @@ -10,7 +10,7 @@ crates = { "ndarray": ("docs", ""), "ndarray-rand": ("", "ndarray-rand"), - "ndarray-rblas": ("", "ndarray-rblas"), + #"ndarray-rblas": ("", "ndarray-rblas"), } def crate_name(s): From 02aeb1f3874d03125fe73c0ddd7e05f6bf77425c Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 09/11] Update README --- README.rst | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/README.rst b/README.rst index a0ebb7c1c..578318d0c 100644 --- a/README.rst +++ b/README.rst @@ -2,11 +2,12 @@ ndarray ========= The ``ndarray`` crate provides an N-dimensional container for general elements -and for numerics. Requires Rust 1.8. +and for numerics. Requires Rust 1.9. -Please read the API documentation here: `(0.5 / master)`__, `(0.4)`__, `(0.3)`__, `(0.2)`__ +Please read the API documentation here: `(0.6 / master)`__, `(0.5)`__, `(0.4)`__, `(0.3)`__, `(0.2)`__ __ http://bluss.github.io/rust-ndarray/ +__ http://bluss.github.io/rust-ndarray/0.5/ __ http://bluss.github.io/rust-ndarray/0.4/ __ http://bluss.github.io/rust-ndarray/0.3/ __ http://bluss.github.io/rust-ndarray/0.2/ @@ -87,6 +88,15 @@ How to use with cargo:: Recent Changes (ndarray) ------------------------ +- 0.6.0 + + - Remove deprecated constructor methods. Use zeros, from_elem, from_shape_vec + or from_shape_vec_unchecked instead. + - Remove deprecated in place arithmetic methods like iadd et.c. Use += et.c. + instead. + - Remove deprecated method mat_mul, use dot instead. + - Require Rust 1.9 + - 0.5.2 - Use num-traits, num-complex instead of num. From 1bd6976763bb9757726a55ecac04cbff7dd35f3c Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 10/11] Rename OwnedArray to Array. The old type alias is deprecated. --- README.rst | 3 +- benches/bench1.rs | 156 ++++++++++++++++---------------- examples/axis.rs | 4 +- examples/convo.rs | 6 +- examples/zip_many.rs | 8 +- ndarray-rand/benches/bench.rs | 6 +- ndarray-rand/src/lib.rs | 8 +- ndarray-rand/tests/tests.rs | 4 +- ndarray-rblas/tests/blas.rs | 34 +++---- ndarray-tests/tests/accuracy.rs | 24 ++--- src/free_functions.rs | 8 +- src/impl_constructors.rs | 28 +++--- src/impl_methods.rs | 20 ++-- src/impl_ops.rs | 22 ++--- src/lib.rs | 26 +++--- src/linalg/impl_linalg.rs | 10 +- src/numeric/impl_numeric.rs | 4 +- src/prelude.rs | 7 +- src/shape_builder.rs | 2 +- src/si.rs | 4 +- src/stacking.rs | 4 +- tests/array.rs | 80 ++++++++-------- tests/complex.rs | 4 +- tests/dimension.rs | 6 +- tests/oper.rs | 44 ++++----- tests/stacking.rs | 4 +- 26 files changed, 268 insertions(+), 258 deletions(-) diff --git a/README.rst b/README.rst index 578318d0c..16e6e1aa6 100644 --- a/README.rst +++ b/README.rst @@ -28,7 +28,7 @@ Highlights - ``ArrayBase``: The N-dimensional array type itself. - - ``OwnedArray``: + - ``Array``: An array where the data is owned uniquely. - ``RcArray``: An array where the data has shared ownership and is copy on write. @@ -90,6 +90,7 @@ Recent Changes (ndarray) - 0.6.0 + - Rename ``OwnedArray`` to ``Array``. The old name is deprecated. - Remove deprecated constructor methods. Use zeros, from_elem, from_shape_vec or from_shape_vec_unchecked instead. - Remove deprecated in place arithmetic methods like iadd et.c. Use += et.c. diff --git a/benches/bench1.rs b/benches/bench1.rs index 7ecfaccf2..c90de6eaa 100644 --- a/benches/bench1.rs +++ b/benches/bench1.rs @@ -6,7 +6,7 @@ extern crate test; extern crate ndarray; use ndarray::{ - OwnedArray, + Array, Axis, Ix, }; @@ -17,7 +17,7 @@ use test::black_box; #[bench] fn map(bench: &mut test::Bencher) { - let a = OwnedArray::linspace(0., 127., 128).into_shape((8, 16)).unwrap(); + let a = Array::linspace(0., 127., 128).into_shape((8, 16)).unwrap(); bench.iter(|| { a.map(|&x| 2. * x) }); @@ -26,7 +26,7 @@ fn map(bench: &mut test::Bencher) #[bench] fn iter_sum_1d_regular(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros(64 * 64); + let a = Array::::zeros(64 * 64); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -41,7 +41,7 @@ fn iter_sum_1d_regular(bench: &mut test::Bencher) fn iter_sum_1d_raw(bench: &mut test::Bencher) { // this is autovectorized to death (= great performance) - let a = OwnedArray::::zeros(64 * 64); + let a = Array::::zeros(64 * 64); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -55,7 +55,7 @@ fn iter_sum_1d_raw(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_regular(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -69,7 +69,7 @@ fn iter_sum_2d_regular(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_by_row(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -86,7 +86,7 @@ fn iter_sum_2d_by_row(bench: &mut test::Bencher) fn iter_sum_2d_raw(bench: &mut test::Bencher) { // this is autovectorized to death (= great performance) - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let a = black_box(a); bench.iter(|| { let mut sum = 0; @@ -100,7 +100,7 @@ fn iter_sum_2d_raw(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_cutout(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((66, 66)); + let a = Array::::zeros((66, 66)); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -115,7 +115,7 @@ fn iter_sum_2d_cutout(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_cutout_by_row(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((66, 66)); + let a = Array::::zeros((66, 66)); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -132,7 +132,7 @@ fn iter_sum_2d_cutout_by_row(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_cutout_outer_iter(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((66, 66)); + let a = Array::::zeros((66, 66)); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -149,7 +149,7 @@ fn iter_sum_2d_cutout_outer_iter(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_transpose_regular(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); + let mut a = Array::::zeros((64, 64)); a.swap_axes(0, 1); let a = black_box(a); bench.iter(|| { @@ -164,7 +164,7 @@ fn iter_sum_2d_transpose_regular(bench: &mut test::Bencher) #[bench] fn iter_sum_2d_transpose_by_row(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); + let mut a = Array::::zeros((64, 64)); a.swap_axes(0, 1); let a = black_box(a); bench.iter(|| { @@ -181,7 +181,7 @@ fn iter_sum_2d_transpose_by_row(bench: &mut test::Bencher) #[bench] fn scalar_sum_2d_regular(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let a = black_box(a); bench.iter(|| { a.scalar_sum() @@ -191,7 +191,7 @@ fn scalar_sum_2d_regular(bench: &mut test::Bencher) #[bench] fn scalar_sum_2d_cutout(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((66, 66)); + let a = Array::::zeros((66, 66)); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -202,7 +202,7 @@ fn scalar_sum_2d_cutout(bench: &mut test::Bencher) #[bench] fn scalar_sum_2d_float(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let a = black_box(a.view()); bench.iter(|| { a.scalar_sum() @@ -212,7 +212,7 @@ fn scalar_sum_2d_float(bench: &mut test::Bencher) #[bench] fn scalar_sum_2d_float_cutout(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((66, 66)); + let a = Array::::zeros((66, 66)); let av = a.slice(s![1..-1, 1..-1]); let a = black_box(av); bench.iter(|| { @@ -223,8 +223,8 @@ fn scalar_sum_2d_float_cutout(bench: &mut test::Bencher) #[bench] fn add_2d_regular(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); - let b = OwnedArray::::zeros((64, 64)); + let mut a = Array::::zeros((64, 64)); + let b = Array::::zeros((64, 64)); let bv = b.view(); bench.iter(|| { a += &bv; @@ -234,8 +234,8 @@ fn add_2d_regular(bench: &mut test::Bencher) #[bench] fn add_2d_assign_ops(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); - let b = OwnedArray::::zeros((64, 64)); + let mut a = Array::::zeros((64, 64)); + let b = Array::::zeros((64, 64)); let bv = b.view(); bench.iter(|| { let mut x = a.view_mut(); @@ -247,9 +247,9 @@ fn add_2d_assign_ops(bench: &mut test::Bencher) #[bench] fn add_2d_cutout(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((66, 66)); + let mut a = Array::::zeros((66, 66)); let mut acut = a.slice_mut(s![1..-1, 1..-1]); - let b = OwnedArray::::zeros((64, 64)); + let b = Array::::zeros((64, 64)); let bv = b.view(); bench.iter(|| { acut += &bv; @@ -259,8 +259,8 @@ fn add_2d_cutout(bench: &mut test::Bencher) #[bench] fn add_2d_broadcast_1_to_2(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); - let b = OwnedArray::::zeros(64); + let mut a = Array::::zeros((64, 64)); + let b = Array::::zeros(64); let bv = b.view(); bench.iter(|| { a += &bv; @@ -270,8 +270,8 @@ fn add_2d_broadcast_1_to_2(bench: &mut test::Bencher) #[bench] fn add_2d_broadcast_0_to_2(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); - let b = OwnedArray::::zeros(()); + let mut a = Array::::zeros((64, 64)); + let b = Array::::zeros(()); let bv = b.view(); bench.iter(|| { a += &bv; @@ -280,7 +280,7 @@ fn add_2d_broadcast_0_to_2(bench: &mut test::Bencher) #[bench] fn scalar_toowned(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); bench.iter(|| { a.to_owned() }); @@ -288,7 +288,7 @@ fn scalar_toowned(bench: &mut test::Bencher) { #[bench] fn scalar_add_1(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let n = 1.; bench.iter(|| { &a + n @@ -297,7 +297,7 @@ fn scalar_add_1(bench: &mut test::Bencher) { #[bench] fn scalar_add_2(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let n = 1.; bench.iter(|| { n + &a @@ -306,7 +306,7 @@ fn scalar_add_2(bench: &mut test::Bencher) { #[bench] fn scalar_sub_1(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let n = 1.; bench.iter(|| { &a - n @@ -315,7 +315,7 @@ fn scalar_sub_1(bench: &mut test::Bencher) { #[bench] fn scalar_sub_2(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); let n = 1.; bench.iter(|| { n - &a @@ -327,7 +327,7 @@ fn scalar_sub_2(bench: &mut test::Bencher) { #[bench] fn add_2d_0_to_2_iadd_scalar(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); + let mut a = Array::::zeros((64, 64)); let n = black_box(0); bench.iter(|| { a += n; @@ -337,9 +337,9 @@ fn add_2d_0_to_2_iadd_scalar(bench: &mut test::Bencher) #[bench] fn add_2d_transposed(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); + let mut a = Array::::zeros((64, 64)); a.swap_axes(0, 1); - let b = OwnedArray::::zeros((64, 64)); + let b = Array::::zeros((64, 64)); let bv = b.view(); bench.iter(|| { a += &bv; @@ -349,8 +349,8 @@ fn add_2d_transposed(bench: &mut test::Bencher) #[bench] fn add_2d_f32_regular(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((64, 64)); - let b = OwnedArray::::zeros((64, 64)); + let mut a = Array::::zeros((64, 64)); + let b = Array::::zeros((64, 64)); let bv = b.view(); bench.iter(|| { a += &bv; @@ -362,8 +362,8 @@ const ADD1D_SIZE: usize = 64 * 64; #[bench] fn add_1d_regular(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros(ADD1D_SIZE); - let b = OwnedArray::::zeros(a.dim()); + let mut a = Array::::zeros(ADD1D_SIZE); + let b = Array::::zeros(a.dim()); bench.iter(|| { a += &b; }); @@ -372,9 +372,9 @@ fn add_1d_regular(bench: &mut test::Bencher) #[bench] fn add_1d_strided(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros(ADD1D_SIZE * 2); + let mut a = Array::::zeros(ADD1D_SIZE * 2); let mut av = a.slice_mut(s![..;2]); - let b = OwnedArray::::zeros(av.dim()); + let b = Array::::zeros(av.dim()); bench.iter(|| { av += &b; }); @@ -383,8 +383,8 @@ fn add_1d_strided(bench: &mut test::Bencher) #[bench] fn scaled_add_2d_f32_regular(bench: &mut test::Bencher) { - let mut av = OwnedArray::::zeros((64, 64)); - let bv = OwnedArray::::zeros((64, 64)); + let mut av = Array::::zeros((64, 64)); + let bv = Array::::zeros((64, 64)); let scalar = 3.1415926535; bench.iter(|| { av.scaled_add(scalar, &bv); @@ -394,7 +394,7 @@ fn scaled_add_2d_f32_regular(bench: &mut test::Bencher) #[bench] fn assign_scalar_2d_corder(bench: &mut test::Bencher) { - let a = OwnedArray::zeros((64, 64)); + let a = Array::zeros((64, 64)); let mut a = black_box(a); let s = 3.; bench.iter(move || a.assign_scalar(&s)) @@ -403,7 +403,7 @@ fn assign_scalar_2d_corder(bench: &mut test::Bencher) #[bench] fn assign_scalar_2d_cutout(bench: &mut test::Bencher) { - let mut a = OwnedArray::zeros((66, 66)); + let mut a = Array::zeros((66, 66)); let a = a.slice_mut(s![1..-1, 1..-1]); let mut a = black_box(a); let s = 3.; @@ -413,7 +413,7 @@ fn assign_scalar_2d_cutout(bench: &mut test::Bencher) #[bench] fn assign_scalar_2d_forder(bench: &mut test::Bencher) { - let mut a = OwnedArray::zeros((64, 64)); + let mut a = Array::zeros((64, 64)); a.swap_axes(0, 1); let mut a = black_box(a); let s = 3.; @@ -423,7 +423,7 @@ fn assign_scalar_2d_forder(bench: &mut test::Bencher) #[bench] fn assign_zero_2d_corder(bench: &mut test::Bencher) { - let a = OwnedArray::zeros((64, 64)); + let a = Array::zeros((64, 64)); let mut a = black_box(a); bench.iter(|| a.assign_scalar(&0.)) } @@ -431,7 +431,7 @@ fn assign_zero_2d_corder(bench: &mut test::Bencher) #[bench] fn assign_zero_2d_cutout(bench: &mut test::Bencher) { - let mut a = OwnedArray::zeros((66, 66)); + let mut a = Array::zeros((66, 66)); let a = a.slice_mut(s![1..-1, 1..-1]); let mut a = black_box(a); bench.iter(|| a.assign_scalar(&0.)) @@ -440,7 +440,7 @@ fn assign_zero_2d_cutout(bench: &mut test::Bencher) #[bench] fn assign_zero_2d_forder(bench: &mut test::Bencher) { - let mut a = OwnedArray::zeros((64, 64)); + let mut a = Array::zeros((64, 64)); a.swap_axes(0, 1); let mut a = black_box(a); bench.iter(|| a.assign_scalar(&0.)) @@ -449,14 +449,14 @@ fn assign_zero_2d_forder(bench: &mut test::Bencher) #[bench] fn bench_iter_diag(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((1024, 1024)); + let a = Array::::zeros((1024, 1024)); bench.iter(|| for elt in a.diag() { black_box(elt); }) } #[bench] fn bench_row_iter(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((1024, 1024)); + let a = Array::::zeros((1024, 1024)); let it = a.row(17); bench.iter(|| for elt in it.clone() { black_box(elt); }) } @@ -464,7 +464,7 @@ fn bench_row_iter(bench: &mut test::Bencher) #[bench] fn bench_col_iter(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((1024, 1024)); + let a = Array::::zeros((1024, 1024)); let it = a.column(17); bench.iter(|| for elt in it.clone() { black_box(elt); }) } @@ -473,13 +473,13 @@ macro_rules! mat_mul { ($modname:ident, $ty:ident, $(($name:ident, $m:expr, $n:expr, $k:expr))+) => { mod $modname { use test::{black_box, Bencher}; - use ndarray::OwnedArray; + use ndarray::Array; $( #[bench] fn $name(bench: &mut Bencher) { - let a = OwnedArray::<$ty, _>::zeros(($m, $n)); - let b = OwnedArray::<$ty, _>::zeros(($n, $k)); + let a = Array::<$ty, _>::zeros(($m, $n)); + let b = Array::<$ty, _>::zeros(($n, $k)); let a = black_box(a.view()); let b = black_box(b.view()); bench.iter(|| a.dot(&b)); @@ -531,7 +531,7 @@ mat_mul!{mat_mul_i32, i32, #[bench] fn create_iter_4d(bench: &mut test::Bencher) { - let mut a = OwnedArray::from_elem((4, 5, 3, 2), 1.0); + let mut a = Array::from_elem((4, 5, 3, 2), 1.0); a.swap_axes(0, 1); a.swap_axes(2, 1); let v = black_box(a.view()); @@ -544,14 +544,14 @@ fn create_iter_4d(bench: &mut test::Bencher) #[bench] fn bench_to_owned_n(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((32, 32)); + let a = Array::::zeros((32, 32)); bench.iter(|| a.to_owned()); } #[bench] fn bench_to_owned_t(bench: &mut test::Bencher) { - let mut a = OwnedArray::::zeros((32, 32)); + let mut a = Array::::zeros((32, 32)); a.swap_axes(0, 1); bench.iter(|| a.to_owned()); } @@ -559,56 +559,56 @@ fn bench_to_owned_t(bench: &mut test::Bencher) #[bench] fn equality_i32(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); - let b = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); + let b = Array::::zeros((64, 64)); bench.iter(|| a == b); } #[bench] fn equality_f32(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros((64, 64)); - let b = OwnedArray::::zeros((64, 64)); + let a = Array::::zeros((64, 64)); + let b = Array::::zeros((64, 64)); bench.iter(|| a == b); } #[bench] fn dot_f32_16(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros(16); - let b = OwnedArray::::zeros(16); + let a = Array::::zeros(16); + let b = Array::::zeros(16); bench.iter(|| a.dot(&b)); } #[bench] fn dot_f32_20(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros(20); - let b = OwnedArray::::zeros(20); + let a = Array::::zeros(20); + let b = Array::::zeros(20); bench.iter(|| a.dot(&b)); } #[bench] fn dot_f32_32(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros(32); - let b = OwnedArray::::zeros(32); + let a = Array::::zeros(32); + let b = Array::::zeros(32); bench.iter(|| a.dot(&b)); } #[bench] fn dot_f32_256(bench: &mut test::Bencher) { - let a = OwnedArray::::zeros(256); - let b = OwnedArray::::zeros(256); + let a = Array::::zeros(256); + let b = Array::::zeros(256); bench.iter(|| a.dot(&b)); } #[bench] fn dot_f32_1024(bench: &mut test::Bencher) { - let av = OwnedArray::::zeros(1024); - let bv = OwnedArray::::zeros(1024); + let av = Array::::zeros(1024); + let bv = Array::::zeros(1024); bench.iter(|| { av.dot(&bv) }); @@ -618,8 +618,8 @@ fn dot_f32_1024(bench: &mut test::Bencher) fn dot_f32_10e6(bench: &mut test::Bencher) { let n = 1_000_000; - let av = OwnedArray::::zeros(n); - let bv = OwnedArray::::zeros(n); + let av = Array::::zeros(n); + let bv = Array::::zeros(n); bench.iter(|| { av.dot(&bv) }); @@ -630,9 +630,9 @@ fn dot_extended(bench: &mut test::Bencher) { let m = 10; let n = 33; let k = 10; - let av = OwnedArray::::zeros((m, n)); - let bv = OwnedArray::::zeros((n, k)); - let mut res = OwnedArray::::zeros((m, k)); + let av = Array::::zeros((m, n)); + let bv = Array::::zeros((n, k)); + let mut res = Array::::zeros((m, k)); // make a manual simple matrix multiply to test bench.iter(|| { for i in 0..m { @@ -647,9 +647,9 @@ fn dot_extended(bench: &mut test::Bencher) { const MEAN_SUM_N: usize = 127; -fn range_mat(m: Ix, n: Ix) -> OwnedArray { +fn range_mat(m: Ix, n: Ix) -> Array { assert!(m * n != 0); - OwnedArray::linspace(0., (m * n - 1) as f32, m * n).into_shape((m, n)).unwrap() + Array::linspace(0., (m * n - 1) as f32, m * n).into_shape((m, n)).unwrap() } #[bench] diff --git a/examples/axis.rs b/examples/axis.rs index 0812f95e9..beeeda2ed 100644 --- a/examples/axis.rs +++ b/examples/axis.rs @@ -1,12 +1,12 @@ extern crate ndarray; use ndarray::{ - OwnedArray, + Array, Axis, }; fn main() { - let a = OwnedArray::::linspace(0., 24., 25).into_shape((5, 5)).unwrap(); + let a = Array::::linspace(0., 24., 25).into_shape((5, 5)).unwrap(); println!("{:?}", a.subview(Axis(0), 0)); println!("{:?}", a.subview(Axis(0), 1)); println!("{:?}", a.subview(Axis(1), 1)); diff --git a/examples/convo.rs b/examples/convo.rs index 50a275d4b..c4105c3e7 100644 --- a/examples/convo.rs +++ b/examples/convo.rs @@ -8,7 +8,7 @@ use num_traits::Float; use ndarray::{ ArrayView, ArrayViewMut, - OwnedArray, + Array, Ix, }; @@ -48,7 +48,7 @@ fn conv_3x3(a: &ArrayView, out: &mut ArrayViewMut, kernel: &K fn main() { let n = 16; - let mut a = OwnedArray::zeros((n, n)); + let mut a = Array::zeros((n, n)); // make a circle let c = (8., 8.); for ((i, j), elt) in a.indexed_iter_mut() { @@ -60,7 +60,7 @@ fn main() { } } println!("{:2}", a); - let mut res = OwnedArray::zeros(a.dim()); + let mut res = Array::zeros(a.dim()); for _ in 0..1000 { conv_3x3(&a.view(), &mut res.view_mut(), &SOBEL_X); } diff --git a/examples/zip_many.rs b/examples/zip_many.rs index 7c647bf83..29641e165 100644 --- a/examples/zip_many.rs +++ b/examples/zip_many.rs @@ -2,7 +2,7 @@ extern crate ndarray; use ndarray::{ - OwnedArray, + Array, ArrayBase, DataMut, Dimension, @@ -66,12 +66,12 @@ define_zip!(zip_3, B, C); fn main() { let n = 16; - let mut a = OwnedArray::::zeros((n, n)); - let mut b = OwnedArray::::from_elem((n, n), 1.); + let mut a = Array::::zeros((n, n)); + let mut b = Array::::from_elem((n, n), 1.); for ((i, j), elt) in b.indexed_iter_mut() { *elt /= 1. + (i + j) as f32; } - let c = OwnedArray::::from_elem((n, n), 1.7); + let c = Array::::from_elem((n, n), 1.7); for _ in 0..1000 { zip_3(&mut a, b.view(), c.view(), |x, &y, &z| *x += y * z).unwrap(); diff --git a/ndarray-rand/benches/bench.rs b/ndarray-rand/benches/bench.rs index 032711753..e0d5032d6 100644 --- a/ndarray-rand/benches/bench.rs +++ b/ndarray-rand/benches/bench.rs @@ -7,7 +7,7 @@ extern crate test; use rand::distributions::Range; use rand::distributions::Normal; -use ndarray::OwnedArray; +use ndarray::Array; use ndarray_rand::RandomExt; use ndarray_rand::F32; @@ -17,7 +17,7 @@ use test::Bencher; fn norm_f32(b: &mut Bencher) { let m = 100; b.iter(|| { - let a = OwnedArray::random((m, m), F32(Normal::new(0., 1.))); + let a = Array::random((m, m), F32(Normal::new(0., 1.))); a }); } @@ -26,7 +26,7 @@ fn norm_f32(b: &mut Bencher) { fn norm_f64(b: &mut Bencher) { let m = 100; b.iter(|| { - let a = OwnedArray::random((m, m), (Normal::new(0., 1.))); + let a = Array::random((m, m), (Normal::new(0., 1.))); a }); } diff --git a/ndarray-rand/src/lib.rs b/ndarray-rand/src/lib.rs index 89cc409d0..11cccbf76 100644 --- a/ndarray-rand/src/lib.rs +++ b/ndarray-rand/src/lib.rs @@ -43,11 +43,11 @@ pub trait RandomExt /// extern crate ndarray_rand; /// /// use rand::distributions::Range; - /// use ndarray::OwnedArray; + /// use ndarray::Array; /// use ndarray_rand::RandomExt; /// /// # fn main() { - /// let a = OwnedArray::random((2, 5), Range::new(0., 10.)); + /// let a = Array::random((2, 5), Range::new(0., 10.)); /// println!("{:8.4}", a); /// // Example Output: /// // [[ 8.6900, 6.9824, 3.8922, 6.5861, 2.4890], @@ -92,11 +92,11 @@ impl RandomExt for ArrayBase /// extern crate ndarray_rand; /// /// use rand::distributions::Normal; -/// use ndarray::OwnedArray; +/// use ndarray::Array; /// use ndarray_rand::{RandomExt, F32}; /// /// # fn main() { -/// let a = OwnedArray::random((2, 5), F32(Normal::new(0., 1.))); +/// let a = Array::random((2, 5), F32(Normal::new(0., 1.))); /// println!("{:8.4}", a); /// // Example Output: /// // [[ -0.6910, 1.1730, 1.0902, -0.4092, -1.7340], diff --git a/ndarray-rand/tests/tests.rs b/ndarray-rand/tests/tests.rs index a36f50d54..b4dd9bde8 100644 --- a/ndarray-rand/tests/tests.rs +++ b/ndarray-rand/tests/tests.rs @@ -4,7 +4,7 @@ extern crate ndarray; extern crate ndarray_rand; use rand::distributions::Range; -use ndarray::OwnedArray; +use ndarray::Array; use ndarray_rand::RandomExt; #[test] @@ -12,7 +12,7 @@ fn test_dim() { let (mm, nn) = (5, 5); for m in 0..mm { for n in 0..nn { - let a = OwnedArray::random((m, n), Range::new(0., 2.)); + let a = Array::random((m, n), Range::new(0., 2.)); assert_eq!(a.shape(), &[m, n]); assert!(a.iter().all(|x| *x <= 2.)); assert!(a.iter().all(|x| *x >= 0.)); diff --git a/ndarray-rblas/tests/blas.rs b/ndarray-rblas/tests/blas.rs index 5825e0835..481b562f3 100644 --- a/ndarray-rblas/tests/blas.rs +++ b/ndarray-rblas/tests/blas.rs @@ -9,7 +9,7 @@ use rblas::attribute::Transpose; use num::Float; use ndarray::{ - OwnedArray, + Array, ArrayView, ArrayViewMut, arr2, @@ -23,9 +23,9 @@ use ndarray_rblas::AsBlas; fn strided_matrix() { // smoke test, a matrix multiplication of uneven size let (n, m) = (45, 33); - let mut a = OwnedArray::linspace(0., ((n * m) - 1) as f32, n as usize * m as usize ).into_shape((n, m)).unwrap(); - let mut b = OwnedArray::eye(m); - let mut res = OwnedArray::zeros(a.dim()); + let mut a = Array::linspace(0., ((n * m) - 1) as f32, n as usize * m as usize ).into_shape((n, m)).unwrap(); + let mut b = Array::eye(m); + let mut res = Array::zeros(a.dim()); Gemm::gemm(&1., Transpose::NoTrans, &a.blas(), Transpose::NoTrans, &b.blas(), &0., &mut res.blas()); assert_eq!(res, a); @@ -35,16 +35,16 @@ fn strided_matrix() { aprim.islice(s![0..12, 0..11]); println!("{:?}", aprim.shape()); println!("{:?}", aprim.strides()); - let mut b = OwnedArray::eye(aprim.shape()[1]); - let mut res = OwnedArray::zeros(aprim.dim()); + let mut b = Array::eye(aprim.shape()[1]); + let mut res = Array::zeros(aprim.dim()); Gemm::gemm(&1., Transpose::NoTrans, &aprim.blas(), Transpose::NoTrans, &b.blas(), &0., &mut res.blas()); assert_eq!(res, aprim); // Transposed matrix multiply let (np, mp) = aprim.dim(); - let mut res = OwnedArray::zeros((mp, np)); - let mut b = OwnedArray::eye(np); + let mut res = Array::zeros((mp, np)); + let mut b = Array::eye(np); Gemm::gemm(&1., Transpose::Trans, &aprim.blas(), Transpose::NoTrans, &b.blas(), &0., &mut res.blas()); let mut at = aprim.clone(); @@ -56,8 +56,8 @@ fn strided_matrix() { abis.islice(s![0..12, ..;2]); println!("{:?}", abis.shape()); println!("{:?}", abis.strides()); - let mut b = OwnedArray::eye(abis.shape()[1]); - let mut res = OwnedArray::zeros(abis.dim()); + let mut b = Array::eye(abis.shape()[1]); + let mut res = Array::zeros(abis.dim()); Gemm::gemm(&1., Transpose::NoTrans, &abis.blas(), Transpose::NoTrans, &b.blas(), &0., &mut res.blas()); assert_eq!(res, abis); @@ -67,9 +67,9 @@ fn strided_matrix() { fn strided_view() { // smoke test, a matrix multiplication of uneven size let (n, m) = (45, 33); - let mut a = OwnedArray::linspace(0., ((n * m) - 1) as f32, n as usize * m as usize ).into_shape((n, m)).unwrap(); - let mut b = OwnedArray::eye(m); - let mut res = OwnedArray::zeros(a.dim()); + let mut a = Array::linspace(0., ((n * m) - 1) as f32, n as usize * m as usize ).into_shape((n, m)).unwrap(); + let mut b = Array::eye(m); + let mut res = Array::zeros(a.dim()); Gemm::gemm(&1., Transpose::NoTrans, &a.blas_view_mut_checked().unwrap(), Transpose::NoTrans, &b.blas_view_mut_checked().unwrap(), @@ -78,8 +78,8 @@ fn strided_view() { // matrix multiplication, strided let aprim = a.slice(s![0..12, 0..11]); - let mut b = OwnedArray::eye(aprim.shape()[1]); - let mut res = OwnedArray::zeros(aprim.dim()); + let mut b = Array::eye(aprim.shape()[1]); + let mut res = Array::zeros(aprim.dim()); Gemm::gemm(&1., Transpose::NoTrans, &aprim.bv(), Transpose::NoTrans, &b.blas(), @@ -89,7 +89,7 @@ fn strided_view() { // test out with matrices where lower axis is strided but has length 1 let mut a3 = arr2(&[[1., 2., 3.]]); a3.swap_axes(0, 1); - let mut b = OwnedArray::eye(a3.shape()[1]); + let mut b = Array::eye(a3.shape()[1]); let mut res = arr2(&[[0., 0., 0.]]); res.swap_axes(0, 1); Gemm::gemm(&1., @@ -101,7 +101,7 @@ fn strided_view() { #[test] fn as_blas() { - let mut a = OwnedArray::::zeros((4, 4)); + let mut a = Array::::zeros((4, 4)); assert!(a.blas_view_mut_checked().is_ok()); a.swap_axes(0, 1); assert!(a.blas_view_mut_checked().is_err()); diff --git a/ndarray-tests/tests/accuracy.rs b/ndarray-tests/tests/accuracy.rs index 0a20bba86..5bd8bc3b5 100644 --- a/ndarray-tests/tests/accuracy.rs +++ b/ndarray-tests/tests/accuracy.rs @@ -9,7 +9,7 @@ use rand::Rng; use ndarray::{ ArrayBase, - OwnedArray, + Array, Dimension, Data, DataMut, @@ -22,7 +22,7 @@ use rand::distributions::Normal; // simple, slow, correct (hopefully) mat mul fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase) - -> OwnedArray + -> Array where A: LinalgScalar, S: Data, S2: Data, @@ -51,21 +51,21 @@ fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase(d: D) -> OwnedArray +fn gen(d: D) -> Array where D: Dimension, { - OwnedArray::random(d, F32(Normal::new(0., 1.))) + Array::random(d, F32(Normal::new(0., 1.))) } -fn gen_f64(d: D) -> OwnedArray +fn gen_f64(d: D) -> Array where D: Dimension, { - OwnedArray::random(d, Normal::new(0., 1.)) + Array::random(d, Normal::new(0., 1.)) } #[test] fn accurate_eye_f32() { for i in 0..20 { - let eye = OwnedArray::eye(i); + let eye = Array::eye(i); for j in 0..20 { let a = gen((i, j)); let a2 = eye.dot(&a); @@ -85,7 +85,7 @@ fn accurate_eye_f32() { let j = rng.gen_range(15, 512); println!("Testing size {} by {}", i, j); let a = gen((i, j)); - let eye = OwnedArray::eye(i); + let eye = Array::eye(i); let a2 = eye.dot(&a); if !a.all_close(&a2, 1e-6) { panic!("Arrays are not equal:\n{:?}\n{:?}\n{:?}", a, a2, &a2 - &a); @@ -101,7 +101,7 @@ fn accurate_eye_f32() { fn accurate_eye_f64() { let abs_tol = 1e-15; for i in 0..20 { - let eye = OwnedArray::eye(i); + let eye = Array::eye(i); for j in 0..20 { let a = gen_f64((i, j)); let a2 = eye.dot(&a); @@ -121,7 +121,7 @@ fn accurate_eye_f64() { let j = rng.gen_range(15, 512); println!("Testing size {} by {}", i, j); let a = gen_f64((i, j)); - let eye = OwnedArray::eye(i); + let eye = Array::eye(i); let a2 = eye.dot(&a); if !a.all_close(&a2, 1e-6) { panic!("Arrays are not equal:\n{:?}\n{:?}\n{:?}", a, a2, &a2 - &a); @@ -212,7 +212,7 @@ trait Utils { fn lift(&mut self, F) where F: FnMut(Self::Elem) -> Self::Elem, Self::Elem: Copy, Self::Data: DataMut; - fn fold_axis(&self, axis: Axis, f: F) -> OwnedArray::Smaller> + fn fold_axis(&self, axis: Axis, f: F) -> Array::Smaller> where Self::Dim: RemoveAxis, Self::Elem: Clone, F: FnMut(&Self::Elem, &Self::Elem) -> Self::Elem; @@ -251,7 +251,7 @@ impl Utils for ArrayBase } } - fn fold_axis(&self, axis: Axis, mut f: F) -> OwnedArray + fn fold_axis(&self, axis: Axis, mut f: F) -> Array where D: RemoveAxis, F: FnMut(&A, &A) -> A, A: Clone, diff --git a/src/free_functions.rs b/src/free_functions.rs index 34037c5c9..9ce951bf9 100644 --- a/src/free_functions.rs +++ b/src/free_functions.rs @@ -11,13 +11,13 @@ use std::slice; use imp_prelude::*; /// Create a zero-dimensional array with the element `x`. -pub fn arr0(x: A) -> OwnedArray +pub fn arr0(x: A) -> Array { unsafe { ArrayBase::from_shape_vec_unchecked((), vec![x]) } } /// Create a one-dimensional array with elements from `xs`. -pub fn arr1(xs: &[A]) -> OwnedArray { +pub fn arr1(xs: &[A]) -> Array { ArrayBase::from_vec(xs.to_vec()) } @@ -121,7 +121,7 @@ impl_arr_init!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,); /// a.shape() == [2, 3] /// ); /// ``` -pub fn arr2>(xs: &[V]) -> OwnedArray { +pub fn arr2>(xs: &[V]) -> Array { let (m, n) = (xs.len() as Ix, V::len() as Ix); let dim = (m, n); let mut result = Vec::::with_capacity(dim.size()); @@ -157,7 +157,7 @@ pub fn rcarr2>(xs: &[V]) -> RcArray, U: FixedInitializer>(xs: &[V]) - -> OwnedArray + -> Array { let dim = (xs.len() as Ix, V::len() as Ix, U::len() as Ix); let mut result = Vec::::with_capacity(dim.size()); diff --git a/src/impl_constructors.rs b/src/impl_constructors.rs index 1da1ba0ff..e05580b64 100644 --- a/src/impl_constructors.rs +++ b/src/impl_constructors.rs @@ -20,7 +20,7 @@ use error::{self, ShapeError, ErrorKind}; /// Constructor methods for one-dimensional arrays. /// -/// Note that the constructor methods apply to `OwnedArray` and `RcArray`, +/// Note that the constructor methods apply to `Array` and `RcArray`, /// the two array types that have owned storage. impl ArrayBase where S: DataOwned @@ -28,9 +28,9 @@ impl ArrayBase /// Create a one-dimensional array from a vector (no copying needed). /// /// ```rust - /// use ndarray::OwnedArray; + /// use ndarray::Array; /// - /// let array = OwnedArray::from_vec(vec![1., 2., 3., 4.]); + /// let array = Array::from_vec(vec![1., 2., 3., 4.]); /// ``` pub fn from_vec(v: Vec) -> ArrayBase { unsafe { Self::from_shape_vec_unchecked(v.len() as Ix, v) } @@ -39,9 +39,9 @@ impl ArrayBase /// Create a one-dimensional array from an iterable. /// /// ```rust - /// use ndarray::{OwnedArray, arr1}; + /// use ndarray::{Array, arr1}; /// - /// let array = OwnedArray::from_iter((0..5).map(|x| x * x)); + /// let array = Array::from_iter((0..5).map(|x| x * x)); /// assert!(array == arr1(&[0, 1, 4, 9, 16])) /// ``` pub fn from_iter(iterable: I) -> ArrayBase @@ -54,9 +54,9 @@ impl ArrayBase /// `[start, end]` with `n` elements. `F` must be a floating point type. /// /// ```rust - /// use ndarray::{OwnedArray, arr1}; + /// use ndarray::{Array, arr1}; /// - /// let array = OwnedArray::linspace(0., 1., 5); + /// let array = Array::linspace(0., 1., 5); /// assert!(array == arr1(&[0.0, 0.25, 0.5, 0.75, 1.0])) /// ``` pub fn linspace(start: F, end: F, n: usize) -> ArrayBase @@ -70,9 +70,9 @@ impl ArrayBase /// `[start, end)` with elements spaced by `step`. `F` must be a floating point type. /// /// ```rust - /// use ndarray::{OwnedArray, arr1}; + /// use ndarray::{Array, arr1}; /// - /// let array = OwnedArray::range(0., 5., 1.); + /// let array = Array::range(0., 5., 1.); /// assert!(array == arr1(&[0., 1., 2., 3., 4.])) /// ``` pub fn range(start: F, end: F, step: F) -> ArrayBase @@ -121,9 +121,9 @@ impl ArrayBase /// **Panics** if the number of elements in `shape` would overflow usize. /// /// ``` - /// use ndarray::{OwnedArray, arr3, ShapeBuilder}; + /// use ndarray::{Array, arr3, ShapeBuilder}; /// - /// let a = OwnedArray::from_elem((2, 2, 2), 1.); + /// let a = Array::from_elem((2, 2, 2), 1.); /// /// assert!( /// a == arr3(&[[[1., 1.], @@ -133,7 +133,7 @@ impl ArrayBase /// ); /// assert!(a.strides() == &[4, 2, 1]); /// - /// let b = OwnedArray::from_elem((2, 2, 2).f(), 1.); + /// let b = Array::from_elem((2, 2, 2).f(), 1.); /// assert!(b.strides() == &[1, 2, 4]); /// ``` pub fn from_elem(shape: Sh, elem: A) -> ArrayBase @@ -190,10 +190,10 @@ impl ArrayBase /// ``` /// use ndarray::prelude::*; /// - /// let a = OwnedArray::from_shape_vec((2, 2), vec![1., 2., 3., 4.]); + /// let a = Array::from_shape_vec((2, 2), vec![1., 2., 3., 4.]); /// assert!(a.is_ok()); /// - /// let b = OwnedArray::from_shape_vec((2, 2).strides((1, 2)), + /// let b = Array::from_shape_vec((2, 2).strides((1, 2)), /// vec![1., 2., 3., 4.]).unwrap(); /// assert!( /// b == arr2(&[[1., 3.], diff --git a/src/impl_methods.rs b/src/impl_methods.rs index d3b4758a5..f817734e0 100644 --- a/src/impl_methods.rs +++ b/src/impl_methods.rs @@ -82,7 +82,7 @@ impl ArrayBase where S: Data, D: Dimension } /// Return an uniquely owned copy of the array - pub fn to_owned(&self) -> OwnedArray + pub fn to_owned(&self) -> Array where A: Clone { let (data, strides) = if let Some(slc) = self.as_slice_memory_order() { @@ -415,7 +415,7 @@ impl ArrayBase where S: Data, D: Dimension /// [6., 7.]]) ///); /// ``` - pub fn select(&self, axis: Axis, indices: &[Ix]) -> OwnedArray + pub fn select(&self, axis: Axis, indices: &[Ix]) -> Array where A: Copy, D: RemoveAxis, { @@ -427,7 +427,7 @@ impl ArrayBase where S: Data, D: Dimension let mut dim = self.dim(); dim.set_axis(axis, 0); unsafe { - OwnedArray::from_shape_vec_unchecked(dim, vec![]) + Array::from_shape_vec_unchecked(dim, vec![]) } } else { stack(axis, &subs).unwrap() @@ -553,10 +553,10 @@ impl ArrayBase where S: Data, D: Dimension /// **Panics** if `axis` is out of bounds. /// /// ``` - /// use ndarray::OwnedArray; + /// use ndarray::Array; /// use ndarray::{arr3, Axis}; /// - /// let a = OwnedArray::from_iter(0..28).into_shape((2, 7, 2)).unwrap(); + /// let a = Array::from_iter(0..28).into_shape((2, 7, 2)).unwrap(); /// let mut iter = a.axis_chunks_iter(Axis(1), 2); /// /// // first iteration yields a 2 × 2 × 2 view @@ -1143,7 +1143,7 @@ impl ArrayBase where S: Data, D: Dimension /// [false, true]]) /// ); /// ``` - pub fn map<'a, B, F>(&'a self, f: F) -> OwnedArray + pub fn map<'a, B, F>(&'a self, f: F) -> Array where F: FnMut(&'a A) -> B, A: 'a, { @@ -1178,7 +1178,7 @@ impl ArrayBase where S: Data, D: Dimension /// [1., 2.]]) /// ); /// ``` - pub fn mapv(&self, f: F) -> OwnedArray + pub fn mapv(&self, f: F) -> Array where F: Fn(A) -> B, A: Clone, { @@ -1265,14 +1265,14 @@ impl ArrayBase where S: Data, D: Dimension /// Combine the elements of each subview with the previous using the `fold` /// function and initial value `init`. /// - /// Return the result as an `OwnedArray`. + /// Return the result as an `Array`. pub fn fold_axis(&self, axis: Axis, init: B, mut fold: F) - -> OwnedArray + -> Array where D: RemoveAxis, F: FnMut(&B, &A) -> B, B: Clone, { - let mut res = OwnedArray::from_elem(self.dim().remove_axis(axis), init); + let mut res = Array::from_elem(self.dim().remove_axis(axis), init); for subview in self.axis_iter(axis) { res.zip_mut_with(&subview, |x, y| *x = fold(x, y)); } diff --git a/src/impl_ops.rs b/src/impl_ops.rs index ca3c4f9b8..6cc0ddfcf 100644 --- a/src/impl_ops.rs +++ b/src/impl_ops.rs @@ -56,7 +56,7 @@ macro_rules! impl_binary_op( /// between `self` and `rhs`, /// and return the result (based on `self`). /// -/// `self` must be an `OwnedArray` or `RcArray`. +/// `self` must be an `Array` or `RcArray`. /// /// If their shapes disagree, `rhs` is broadcast to the shape of `self`. /// @@ -103,7 +103,7 @@ impl<'a, A, S, S2, D, E> $trt<&'a ArrayBase> for ArrayBase /// Perform elementwise #[doc=$doc] /// between references `self` and `rhs`, -/// and return the result as a new `OwnedArray`. +/// and return the result as a new `Array`. /// /// If their shapes disagree, `rhs` is broadcast to the shape of `self`. /// @@ -115,8 +115,8 @@ impl<'a, 'b, A, S, S2, D, E> $trt<&'a ArrayBase> for &'b ArrayBase D: Dimension, E: Dimension, { - type Output = OwnedArray; - fn $mth(self, rhs: &'a ArrayBase) -> OwnedArray { + type Output = Array; + fn $mth(self, rhs: &'a ArrayBase) -> Array { // FIXME: Can we co-broadcast arrays here? And how? self.to_owned().$mth(rhs) } @@ -127,7 +127,7 @@ impl<'a, 'b, A, S, S2, D, E> $trt<&'a ArrayBase> for &'b ArrayBase /// between `self` and the scalar `x`, /// and return the result (based on `self`). /// -/// `self` must be an `OwnedArray` or `RcArray`. +/// `self` must be an `Array` or `RcArray`. impl $trt for ArrayBase where A: Clone + $trt, S: DataOwned + DataMut, @@ -146,15 +146,15 @@ impl $trt for ArrayBase /// Perform elementwise #[doc=$doc] /// between the reference `self` and the scalar `x`, -/// and return the result as a new `OwnedArray`. +/// and return the result as a new `Array`. impl<'a, A, S, D, B> $trt for &'a ArrayBase where A: Clone + $trt, S: Data, D: Dimension, B: ScalarOperand, { - type Output = OwnedArray; - fn $mth(self, x: B) -> OwnedArray { + type Output = Array; + fn $mth(self, x: B) -> Array { self.to_owned().$mth(x) } } @@ -195,13 +195,13 @@ impl $trt> for $scalar // Perform elementwise // between the scalar `self` and array `rhs`, -// and return the result as a new `OwnedArray`. +// and return the result as a new `Array`. impl<'a, S, D> $trt<&'a ArrayBase> for $scalar where S: Data, D: Dimension, { - type Output = OwnedArray<$scalar, D>; - fn $mth(self, rhs: &ArrayBase) -> OwnedArray<$scalar, D> { + type Output = Array<$scalar, D>; + fn $mth(self, rhs: &ArrayBase) -> Array<$scalar, D> { if_commutative!($commutative { rhs.$mth(self) } or { diff --git a/src/lib.rs b/src/lib.rs index 6609703e3..7a9a4d0ec 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -13,7 +13,7 @@ //! //! - [`ArrayBase`](struct.ArrayBase.html): //! The N-dimensional array type itself. -//! - [`OwnedArray`](type.OwnedArray.html): +//! - [`Array`](type.Array.html): //! An array where the data is owned uniquely. //! - [`RcArray`](type.RcArray.html): //! An array where the data has shared ownership and is copy on write. @@ -26,7 +26,7 @@ //! - Slicing, also with arbitrary step size, and negative indices to mean //! elements from the end of the axis. //! - There is both a copy on write array (`RcArray`), or a regular uniquely owned array -//! (`OwnedArray`), and both can use read-only and read-write array views. +//! (`Array`), and both can use read-only and read-write array views. //! - Iteration and most operations are efficient on arrays with contiguous //! innermost dimension. //! - Array views can be used to slice and mutate any `[T]` data using @@ -173,17 +173,17 @@ pub type Ixs = isize; /// The `ArrayBase` is parameterized by `S` for the data container and /// `D` for the dimensionality. /// -/// Type aliases [`OwnedArray`], [`RcArray`], [`ArrayView`], and [`ArrayViewMut`] refer +/// Type aliases [`Array`], [`RcArray`], [`ArrayView`], and [`ArrayViewMut`] refer /// to `ArrayBase` with different types for the data container. /// -/// [`OwnedArray`]: type.OwnedArray.html +/// [`Array`]: type.Array.html /// [`RcArray`]: type.RcArray.html /// [`ArrayView`]: type.ArrayView.html /// [`ArrayViewMut`]: type.ArrayViewMut.html /// /// ## Contents /// -/// + [OwnedArray and RcArray](#ownedarray-and-rcarray) +/// + [Array and RcArray](#ownedarray-and-rcarray) /// + [Indexing and Dimension](#indexing-and-dimension) /// + [Slicing](#slicing) /// + [Subviews](#subviews) @@ -192,9 +192,9 @@ pub type Ixs = isize; /// + [Methods](#methods) /// + [Methods for Array Views](#methods-for-array-views) /// -/// ## `OwnedArray` and `RcArray` +/// ## `Array` and `RcArray` /// -/// `OwnedArray` owns the underlying array elements directly (just like +/// `Array` owns the underlying array elements directly (just like /// a `Vec`), while [`RcArray`](type.RcArray.html) is a an array with reference /// counted data. `RcArray` can act both as an owner or as a view in that regard. /// Sharing requires that it uses copy-on-write for mutable operations. @@ -351,14 +351,14 @@ pub type Ixs = isize; /// Since the trait implementations are hard to overview, here is a summary. /// /// Let `A` be an array or view of any kind. Let `B` be an array -/// with owned storage (either `OwnedArray` or `RcArray`). -/// Let `C` be an array with mutable data (either `OwnedArray`, `RcArray` +/// with owned storage (either `Array` or `RcArray`). +/// Let `C` be an array with mutable data (either `Array`, `RcArray` /// or `ArrayViewMut`). /// The following combinations of operands /// are supported for an arbitrary binary operator denoted by `@` (it can be /// `+`, `-`, `*`, `/` and so on). /// -/// - `&A @ &A` which produces a new `OwnedArray` +/// - `&A @ &A` which produces a new `Array` /// - `B @ A` which consumes `B`, updates it with the result, and returns it /// - `B @ &A` which consumes `B`, updates it with the result, and returns it /// - `C @= &A` which performs an arithmetic operation in place @@ -368,7 +368,7 @@ pub type Ixs = isize; /// are supported (scalar can be on either the left or right side, but /// `ScalarOperand` docs has the detailed condtions). /// -/// - `&A @ K` or `K @ &A` which produces a new `OwnedArray` +/// - `&A @ K` or `K @ &A` which produces a new `Array` /// - `B @ K` or `K @ B` which consumes `B`, updates it with the result and returns it /// - `C @= K` which performs an arithmetic operation in place /// @@ -413,6 +413,10 @@ pub struct ArrayBase /// can act as both an owner as the data as well as a lightweight view. pub type RcArray = ArrayBase>, D>; +/// Array where the data is owned uniquely. +pub type Array = ArrayBase, D>; + +#[deprecated(note="Use the type alias `Array` instead")] /// Array where the data is owned uniquely. pub type OwnedArray = ArrayBase, D>; diff --git a/src/linalg/impl_linalg.rs b/src/linalg/impl_linalg.rs index 08ddcdd56..2a8af7ecc 100644 --- a/src/linalg/impl_linalg.rs +++ b/src/linalg/impl_linalg.rs @@ -194,9 +194,9 @@ impl Dot> for ArrayBase S2: Data, A: LinalgScalar, { - type Output = OwnedArray; + type Output = Array; fn dot(&self, b: &ArrayBase) - -> OwnedArray + -> Array { let a = self.view(); let b = b.view(); @@ -213,7 +213,7 @@ impl Dot> for ArrayBase let mut c; unsafe { v.set_len(m * n); - c = OwnedArray::from_shape_vec_unchecked((m, n).set_f(column_major), v); + c = Array::from_shape_vec_unchecked((m, n).set_f(column_major), v); } mat_mul_impl(A::one(), &a, &b, A::zero(), &mut c.view_mut()); c @@ -251,8 +251,8 @@ impl Dot> for ArrayBase S2: Data, A: LinalgScalar, { - type Output = OwnedArray; - fn dot(&self, rhs: &ArrayBase) -> OwnedArray + type Output = Array; + fn dot(&self, rhs: &ArrayBase) -> Array { let ((m, a), n) = (self.dim(), rhs.dim()); if a != n { diff --git a/src/numeric/impl_numeric.rs b/src/numeric/impl_numeric.rs index 833939605..04c35ca7b 100644 --- a/src/numeric/impl_numeric.rs +++ b/src/numeric/impl_numeric.rs @@ -64,7 +64,7 @@ impl ArrayBase /// ``` /// /// **Panics** if `axis` is out of bounds. - pub fn sum(&self, axis: Axis) -> OwnedArray::Smaller> + pub fn sum(&self, axis: Axis) -> Array::Smaller> where A: Clone + Zero + Add, D: RemoveAxis, { @@ -100,7 +100,7 @@ impl ArrayBase /// a.mean(Axis(1)) == aview1(&[1.5, 3.5]) /// ); /// ``` - pub fn mean(&self, axis: Axis) -> OwnedArray::Smaller> + pub fn mean(&self, axis: Axis) -> Array::Smaller> where A: LinalgScalar, D: RemoveAxis, { diff --git a/src/prelude.rs b/src/prelude.rs index 2e422b877..03ce6fe82 100644 --- a/src/prelude.rs +++ b/src/prelude.rs @@ -21,11 +21,16 @@ #[doc(no_inline)] pub use { ArrayBase, - OwnedArray, + Array, RcArray, ArrayView, ArrayViewMut, }; + +#[doc(no_inline)] +#[allow(deprecated)] +pub use OwnedArray; + #[doc(no_inline)] pub use { Axis, diff --git a/src/shape_builder.rs b/src/shape_builder.rs index 2b548c45d..5001f1d6d 100644 --- a/src/shape_builder.rs +++ b/src/shape_builder.rs @@ -6,7 +6,7 @@ use {Shape, StrideShape}; /// customizing the memory layout (strides) of an array shape. /// /// This trait is used together with array constructor methods like -/// `OwnedArray::from_shape_vec`. +/// `Array::from_shape_vec`. pub trait ShapeBuilder { type Dim: Dimension; diff --git a/src/si.rs b/src/si.rs index 1600d48ed..8ae8ede3a 100644 --- a/src/si.rs +++ b/src/si.rs @@ -111,10 +111,10 @@ pub const S: Si = Si(0, None, 1); /// use ndarray::{ /// ArrayView, /// Ix, -/// OwnedArray, +/// Array, /// }; /// -/// fn laplacian(v: &ArrayView) -> OwnedArray { +/// fn laplacian(v: &ArrayView) -> Array { /// -4. * &v.slice(s![1..-1, 1..-1]) /// + v.slice(s![ ..-2, 1..-1]) /// + v.slice(s![1..-1, ..-2]) diff --git a/src/stacking.rs b/src/stacking.rs index e4233eb60..74cc57f29 100644 --- a/src/stacking.rs +++ b/src/stacking.rs @@ -30,7 +30,7 @@ use error::{ShapeError, ErrorKind, from_kind}; /// ); /// ``` pub fn stack<'a, A, D>(axis: Axis, arrays: &[ArrayView<'a, A, D>]) - -> Result, ShapeError> + -> Result, ShapeError> where A: Copy, D: RemoveAxis { @@ -57,7 +57,7 @@ pub fn stack<'a, A, D>(axis: Axis, arrays: &[ArrayView<'a, A, D>]) unsafe { v.set_len(size); } - let mut res = try!(OwnedArray::from_shape_vec(res_dim, v)); + let mut res = try!(Array::from_shape_vec(res_dim, v)); { let mut assign_view = res.view_mut(); diff --git a/tests/array.rs b/tests/array.rs index 32ea4ac70..1aeeede86 100644 --- a/tests/array.rs +++ b/tests/array.rs @@ -69,7 +69,7 @@ fn test_slice() #[should_panic] #[test] fn index_out_of_bounds() { - let mut a = OwnedArray::::zeros((3, 4)); + let mut a = Array::::zeros((3, 4)); a[[3, 2]] = 1; } @@ -299,7 +299,7 @@ fn assign() assert_eq!(a, RcArray::zeros((2, 2))); /* Test other type */ - a.assign(&OwnedArray::from_elem((2, 2), 3.)); + a.assign(&Array::from_elem((2, 2), 3.)); assert_eq!(a, RcArray::from_elem((2, 2), 3.)); /* Test mut view */ @@ -419,7 +419,7 @@ fn as_slice_memory_order() #[test] fn owned_array1() { - let mut a = OwnedArray::from_vec(vec![1, 2, 3, 4]); + let mut a = Array::from_vec(vec![1, 2, 3, 4]); for elt in a.iter_mut() { *elt = 2; } @@ -428,7 +428,7 @@ fn owned_array1() { } assert_eq!(a.shape(), &[4]); - let mut a = OwnedArray::zeros((2, 2)); + let mut a = Array::zeros((2, 2)); let mut b = RcArray::zeros((2, 2)); a[(1, 1)] = 3; b[(1, 1)] = 3; @@ -448,7 +448,7 @@ fn owned_array_with_stride() { let dim = (2, 3, 2); let strides = (1, 4, 2); - let a = OwnedArray::from_shape_vec(dim.strides(strides), v).unwrap(); + let a = Array::from_shape_vec(dim.strides(strides), v).unwrap(); assert_eq!(a.strides(), &[1, 4, 2]); } @@ -465,7 +465,7 @@ macro_rules! assert_matches { #[test] fn from_vec_dim_stride_empty_1d() { let empty: [f32; 0] = []; - assert_matches!(OwnedArray::from_shape_vec(0.strides(1), empty.to_vec()), + assert_matches!(Array::from_shape_vec(0.strides(1), empty.to_vec()), Ok(_)); } @@ -475,11 +475,11 @@ fn from_vec_dim_stride_0d() { let one = [1.]; let two = [1., 2.]; // too few elements - assert_matches!(OwnedArray::from_shape_vec(().strides(()), empty.to_vec()), Err(_)); + assert_matches!(Array::from_shape_vec(().strides(()), empty.to_vec()), Err(_)); // exact number of elements - assert_matches!(OwnedArray::from_shape_vec(().strides(()), one.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(().strides(()), one.to_vec()), Ok(_)); // too many are ok - assert_matches!(OwnedArray::from_shape_vec(().strides(()), two.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(().strides(()), two.to_vec()), Ok(_)); } #[test] @@ -487,7 +487,7 @@ fn from_vec_dim_stride_2d_1() { let two = [1., 2.]; let d = (2, 1); let s = d.default_strides(); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), two.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Ok(_)); } #[test] @@ -495,7 +495,7 @@ fn from_vec_dim_stride_2d_2() { let two = [1., 2.]; let d = (1, 2); let s = d.default_strides(); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), two.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Ok(_)); } #[test] @@ -505,7 +505,7 @@ fn from_vec_dim_stride_2d_3() { [[3]]]); let d = a.dim(); let s = d.default_strides(); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_)); } #[test] @@ -515,7 +515,7 @@ fn from_vec_dim_stride_2d_4() { [[3]]]); let d = a.dim(); let s = d.fortran_strides(); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_)); } #[test] @@ -523,7 +523,7 @@ fn from_vec_dim_stride_2d_5() { let a = arr3(&[[[1, 2, 3]]]); let d = a.dim(); let s = d.fortran_strides(); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), a.as_slice().unwrap().to_vec()), Ok(_)); } #[test] @@ -531,11 +531,11 @@ fn from_vec_dim_stride_2d_6() { let a = [1., 2., 3., 4., 5., 6.]; let d = (2, 1, 1); let s = (2, 2, 1); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); let d = (1, 2, 1); let s = (2, 2, 1); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); } #[test] @@ -545,7 +545,7 @@ fn from_vec_dim_stride_2d_7() { // [[]] shape=[4, 0], strides=[0, 1] let d = (4, 0); let s = (0, 1); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Ok(_)); } #[test] @@ -554,7 +554,7 @@ fn from_vec_dim_stride_2d_8() { let a = [1.]; let d = (1, 1); let s = (0, 1); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), a.to_vec()), Err(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), a.to_vec()), Err(_)); } #[test] @@ -562,11 +562,11 @@ fn from_vec_dim_stride_2d_rejects() { let two = [1., 2.]; let d = (2, 2); let s = (1, 0); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), two.to_vec()), Err(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Err(_)); let d = (2, 2); let s = (0, 1); - assert_matches!(OwnedArray::from_shape_vec(d.strides(s), two.to_vec()), Err(_)); + assert_matches!(Array::from_shape_vec(d.strides(s), two.to_vec()), Err(_)); } #[test] @@ -590,7 +590,7 @@ fn view_mut() { for elt in &mut a.view_mut() { *elt = 0; } - assert_eq!(a, OwnedArray::zeros((2, 2))); + assert_eq!(a, Array::zeros((2, 2))); { let mut b = a.view_mut(); b[(0, 0)] = 7; @@ -735,7 +735,7 @@ fn reshape_error2() { #[test] fn reshape_f() { - let mut u = OwnedArray::zeros((3, 4).f()); + let mut u = Array::zeros((3, 4).f()); for (i, elt) in enumerate(u.as_slice_memory_order_mut().unwrap()) { *elt = i as i32; } @@ -781,13 +781,13 @@ fn char_array() #[test] fn scalar_ops() { - let a = OwnedArray::::zeros((5, 5)); + let a = Array::::zeros((5, 5)); let b = &a + 1; let c = (&a + &a + 2) - 3; println!("{:?}", b); println!("{:?}", c); - let a = OwnedArray::::zeros((2, 2)); + let a = Array::::zeros((2, 2)); let b = (1. + a) * 3.; assert_eq!(b, arr2(&[[3., 3.], [3., 3.]])); @@ -799,7 +799,7 @@ fn scalar_ops() { assert_eq!(b, arr1(&[true, false, false])); assert_eq!(true ^ &a, !a); - let zero = OwnedArray::::zeros((2, 2)); + let zero = Array::::zeros((2, 2)); let one = &zero + 1.; assert_eq!(0. * &one, zero); assert_eq!(&one * 0., zero); @@ -807,7 +807,7 @@ fn scalar_ops() { assert_eq!(&one / 2., 0.5 * &one); assert_eq!(&one % 1., zero); - let zero = OwnedArray::::zeros((2, 2)); + let zero = Array::::zeros((2, 2)); let one = &zero + 1; assert_eq!(one.clone() << 3, 8 * &one); assert_eq!(3 << one.clone() , 6 * &one); @@ -819,9 +819,9 @@ fn scalar_ops() { #[test] fn deny_wraparound_from_vec() { let five = vec![0; 5]; - let five_large = OwnedArray::from_shape_vec((3, 7, 29, 36760123, 823996703), five.clone()); + let five_large = Array::from_shape_vec((3, 7, 29, 36760123, 823996703), five.clone()); assert!(five_large.is_err()); - let six = OwnedArray::from_shape_vec(6, five.clone()); + let six = Array::from_shape_vec(6, five.clone()); assert!(six.is_err()); } @@ -829,14 +829,14 @@ fn deny_wraparound_from_vec() { #[test] fn deny_wraparound_zeros() { //2^64 + 5 = 18446744073709551621 = 3×7×29×36760123×823996703 (5 distinct prime factors) - let _five_large = OwnedArray::::zeros((3, 7, 29, 36760123, 823996703)); + let _five_large = Array::::zeros((3, 7, 29, 36760123, 823996703)); } #[should_panic] #[test] fn deny_wraparound_reshape() { //2^64 + 5 = 18446744073709551621 = 3×7×29×36760123×823996703 (5 distinct prime factors) - let five = OwnedArray::::zeros(5); + let five = Array::::zeros(5); let _five_large = five.into_shape((3, 7, 29, 36760123, 823996703)).unwrap(); } @@ -889,23 +889,23 @@ fn deny_split_at_index_out_of_bounds() { #[test] fn test_range() { - let a = OwnedArray::range(0., 5., 1.); + let a = Array::range(0., 5., 1.); assert_eq!(a.len(), 5); assert_eq!(a[0], 0.); assert_eq!(a[4], 4.); - let b = OwnedArray::range(0., 2.2, 1.); + let b = Array::range(0., 2.2, 1.); assert_eq!(b.len(), 3); assert_eq!(b[0], 0.); assert_eq!(b[2], 2.); - let c = OwnedArray::range(0., 5., 2.); + let c = Array::range(0., 5., 2.); assert_eq!(c.len(), 3); assert_eq!(c[0], 0.); assert_eq!(c[1], 2.); assert_eq!(c[2], 4.); - let d = OwnedArray::range(1.0, 2.2, 0.1); + let d = Array::range(1.0, 2.2, 0.1); assert_eq!(d.len(), 13); assert_eq!(d[0], 1.); assert_eq!(d[10], 2.); @@ -918,7 +918,7 @@ fn test_f_order() { // even if the underlying memory order is different let c = arr2(&[[1, 2, 3], [4, 5, 6]]); - let mut f = OwnedArray::zeros(c.dim().f()); + let mut f = Array::zeros(c.dim().f()); f.assign(&c); assert_eq!(f, c); assert_eq!(f.shape(), c.shape()); @@ -984,8 +984,8 @@ fn test_contiguous() { assert!(!v.is_standard_layout()); assert!(v.as_slice_memory_order().is_some()); - let a = OwnedArray::::zeros((20, 1)); - let b = OwnedArray::::zeros((20, 1).f()); + let a = Array::::zeros((20, 1)); + let b = Array::::zeros((20, 1).f()); assert!(a.as_slice().is_some()); assert!(b.as_slice().is_some()); assert!(a.as_slice_memory_order().is_some()); @@ -1026,9 +1026,9 @@ fn test_swap() { #[test] fn test_shape() { let data = [0, 1, 2, 3, 4, 5]; - let a = OwnedArray::from_shape_vec((1, 2, 3), data.to_vec()).unwrap(); - let b = OwnedArray::from_shape_vec((1, 2, 3).f(), data.to_vec()).unwrap(); - let c = OwnedArray::from_shape_vec((1, 2, 3).strides((1, 3, 1)), data.to_vec()).unwrap(); + let a = Array::from_shape_vec((1, 2, 3), data.to_vec()).unwrap(); + let b = Array::from_shape_vec((1, 2, 3).f(), data.to_vec()).unwrap(); + let c = Array::from_shape_vec((1, 2, 3).strides((1, 3, 1)), data.to_vec()).unwrap(); println!("{:?}", a); println!("{:?}", b); println!("{:?}", c); diff --git a/tests/complex.rs b/tests/complex.rs index 01fbd44fb..61e5c51e1 100644 --- a/tests/complex.rs +++ b/tests/complex.rs @@ -4,7 +4,7 @@ extern crate num_complex; extern crate ndarray; use ndarray::{arr1, arr2, Axis}; -use ndarray::OwnedArray; +use ndarray::Array; use num_traits::Num; use num_complex::Complex; @@ -18,7 +18,7 @@ fn complex_mat_mul() let a = arr2(&[[c(3., 4.), c(2., 0.)], [c(0., -2.), c(3., 0.)]]); let b = (&a * c(3., 0.)).map(|c| 5. * c / c.norm()); println!("{:>8.2}", b); - let e = OwnedArray::eye(2); + let e = Array::eye(2); let r = a.dot(&e); println!("{}", a); assert_eq!(r, a); diff --git a/tests/dimension.rs b/tests/dimension.rs index cbc843f3e..d8c88c696 100644 --- a/tests/dimension.rs +++ b/tests/dimension.rs @@ -2,7 +2,7 @@ extern crate ndarray; use ndarray::{ RcArray, - OwnedArray, + Array, RemoveAxis, arr2, Axis, @@ -31,14 +31,14 @@ fn remove_axis() fn dyn_dimension() { let a = arr2(&[[1., 2.], [3., 4.0]]).into_shape(vec![2, 2]).unwrap(); - assert_eq!(&a - &a, OwnedArray::zeros(vec![2, 2])); + assert_eq!(&a - &a, Array::zeros(vec![2, 2])); assert_eq!(a[&[0, 0][..]], 1.); assert_eq!(a[vec![0, 0]], 1.); let mut dim = vec![1; 1024]; dim[16] = 4; dim[17] = 3; - let z = OwnedArray::::zeros(dim.clone()); + let z = Array::::zeros(dim.clone()); assert_eq!(z.shape(), &dim[..]); } diff --git a/tests/oper.rs b/tests/oper.rs index 5d8384afa..479fb7621 100644 --- a/tests/oper.rs +++ b/tests/oper.rs @@ -148,7 +148,7 @@ fn reference_dot<'a,A, V1, V2>(a: V1, b: V2) -> A #[test] fn dot_product() { - let a = OwnedArray::range(0., 69., 1.); + let a = Array::range(0., 69., 1.); let b = &a * 2. - 7.; let dot = 197846.; assert_approx_eq(a.dot(&b), reference_dot(&a, &b), 1e-5); @@ -187,7 +187,7 @@ fn dot_product() { // test that we can dot product with a broadcast array #[test] fn dot_product_0() { - let a = OwnedArray::range(0., 69., 1.); + let a = Array::range(0., 69., 1.); let x = 1.5; let b = aview0(&x); let b = b.broadcast(a.dim()).unwrap(); @@ -208,7 +208,7 @@ fn dot_product_0() { #[test] fn dot_product_neg_stride() { // test that we can dot with negative stride - let a = OwnedArray::range(0., 69., 1.); + let a = Array::range(0., 69., 1.); let b = &a * 2. - 7.; for stride in -10..0 { // both negative @@ -224,21 +224,21 @@ fn dot_product_neg_stride() { } } -fn range_mat(m: Ix, n: Ix) -> OwnedArray { - OwnedArray::linspace(0., (m * n - 1) as f32, m * n).into_shape((m, n)).unwrap() +fn range_mat(m: Ix, n: Ix) -> Array { + Array::linspace(0., (m * n - 1) as f32, m * n).into_shape((m, n)).unwrap() } -fn range_mat64(m: Ix, n: Ix) -> OwnedArray { - OwnedArray::linspace(0., (m * n - 1) as f64, m * n).into_shape((m, n)).unwrap() +fn range_mat64(m: Ix, n: Ix) -> Array { + Array::linspace(0., (m * n - 1) as f64, m * n).into_shape((m, n)).unwrap() } -fn range_i32(m: Ix, n: Ix) -> OwnedArray { - OwnedArray::from_iter(0..(m * n) as i32).into_shape((m, n)).unwrap() +fn range_i32(m: Ix, n: Ix) -> Array { + Array::from_iter(0..(m * n) as i32).into_shape((m, n)).unwrap() } // simple, slow, correct (hopefully) mat mul fn reference_mat_mul(lhs: &ArrayBase, rhs: &ArrayBase) - -> OwnedArray + -> Array where A: LinalgScalar, S: Data, S2: Data, @@ -281,8 +281,8 @@ fn mat_mul() { } let ab = a.dot(&b); - let mut af = OwnedArray::zeros(a.dim().f()); - let mut bf = OwnedArray::zeros(b.dim().f()); + let mut af = Array::zeros(a.dim().f()); + let mut bf = Array::zeros(b.dim().f()); af.assign(&a); bf.assign(&b); @@ -300,8 +300,8 @@ fn mat_mul() { } let ab = a.dot(&b); - let mut af = OwnedArray::zeros(a.dim().f()); - let mut bf = OwnedArray::zeros(b.dim().f()); + let mut af = Array::zeros(a.dim().f()); + let mut bf = Array::zeros(b.dim().f()); af.assign(&a); bf.assign(&b); @@ -319,8 +319,8 @@ fn mat_mul() { } let ab = a.dot(&b); - let mut af = OwnedArray::zeros(a.dim().f()); - let mut bf = OwnedArray::zeros(b.dim().f()); + let mut af = Array::zeros(a.dim().f()); + let mut bf = Array::zeros(b.dim().f()); af.assign(&a); bf.assign(&b); @@ -336,8 +336,8 @@ fn mat_mul_order() { let (m, n, k) = (8, 8, 8); let a = range_mat(m, n); let b = range_mat(n, k); - let mut af = OwnedArray::zeros(a.dim().f()); - let mut bf = OwnedArray::zeros(b.dim().f()); + let mut af = Array::zeros(a.dim().f()); + let mut bf = Array::zeros(b.dim().f()); af.assign(&a); bf.assign(&b); @@ -376,11 +376,11 @@ fn mat_mul_broadcast() { let (m, n, k) = (16, 16, 16); let a = range_mat(m, n); let x1 = 1.; - let x = OwnedArray::from_vec(vec![x1]); + let x = Array::from_vec(vec![x1]); let b0 = x.broadcast((n, k)).unwrap(); - let b1 = OwnedArray::from_elem(n, x1); + let b1 = Array::from_elem(n, x1); let b1 = b1.broadcast((n, k)).unwrap(); - let b2 = OwnedArray::from_elem((n, k), x1); + let b2 = Array::from_elem((n, k), x1); let c2 = a.dot(&b2); let c1 = a.dot(&b1); @@ -395,7 +395,7 @@ fn mat_mul_rev() { let (m, n, k) = (16, 16, 16); let a = range_mat(m, n); let b = range_mat(n, k); - let mut rev = OwnedArray::zeros(b.dim()); + let mut rev = Array::zeros(b.dim()); let mut rev = rev.slice_mut(s![..;-1, ..]); rev.assign(&b); println!("{:.?}", rev); diff --git a/tests/stacking.rs b/tests/stacking.rs index 65be6993f..edf0f2485 100644 --- a/tests/stacking.rs +++ b/tests/stacking.rs @@ -8,7 +8,7 @@ use ndarray::{ arr2, Axis, Ix, - OwnedArray, + Array, ErrorKind, }; @@ -39,6 +39,6 @@ fn stacking() { let res = ndarray::stack(Axis(2), &[a.view(), c.view()]); assert_eq!(res.unwrap_err().kind(), ErrorKind::OutOfBounds); - let res: Result, _> = ndarray::stack(Axis(0), &[]); + let res: Result, _> = ndarray::stack(Axis(0), &[]); assert_eq!(res.unwrap_err().kind(), ErrorKind::Unsupported); } From 04b17b4f7f07659efb621e05fc0c4b9808a3d66d Mon Sep 17 00:00:00 2001 From: bluss Date: Mon, 6 Jun 2016 14:37:48 +0200 Subject: [PATCH 11/11] 0.6.0 --- Cargo.toml | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index fbbd1d633..008a4d452 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "ndarray" -version = "0.5.2" +version = "0.6.0" authors = ["bluss"] license = "MIT/Apache-2.0" @@ -28,7 +28,7 @@ version = "0.1.32" default-features = false [dependencies.itertools] -version = "0.4.6" +version = "0.4.15" [dependencies.rustc-serialize] version = "0.3.16" @@ -36,8 +36,7 @@ optional = true [dependencies] # Use via the `blas` crate feature! -blas-sys = { version = "0.6.2", optional = true, default-features = false } -openblas-provider = { version = "0.4.1", optional = true, default-features = false } +blas-sys = { version = "0.6.3", optional = true, default-features = false } matrixmultiply = { version = "0.1.8" } [features]