Merge branch 'master' into mean-fromprimitive

Author: bluss

.travis.yml

@@ -4,22 +4,23 @@ sudo: required
 dist: trusty
 matrix:
   include:
-    - rust: 1.27.0
+    - rust: 1.30.0
       env:
        - FEATURES='test docs'
     - rust: stable
       env:
        - FEATURES='test docs'
-       - CARGO_INCREMENTAL=0
     - rust: beta
       env:
        - FEATURES='test docs'
-       - CARGO_INCREMENTAL=0
     - rust: nightly
       env:
        - FEATURES='test docs'
        - IS_NIGHTLY=1
-       - CARGO_INCREMENTAL=0
+env:
+  global:
+    - HOST=x86_64-unknown-linux-gnu
+    - CARGO_INCREMENTAL=0
 branches:
   only:
     - master

Cargo.toml

@@ -1,12 +1,15 @@
 [package]
 
 name = "ndarray"
-version = "0.12.0"
-authors = ["bluss"]
+version = "0.12.1"
+authors = [
+  "bluss",
+  "Jim Turner"
+]
 license = "MIT/Apache-2.0"
 readme = "README-crates.io.md"
 
-repository = "https://github.com/bluss/ndarray"
+repository = "https://github.com/rust-ndarray/ndarray"
 documentation = "https://docs.rs/ndarray/"
 
 description = "An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting."
@@ -33,12 +36,13 @@ itertools = { version = "0.7.0", default-features = false }
 cblas-sys = { version = "0.1.4", optional = true, default-features = false }
 blas-src = { version = "0.2.0", optional = true, default-features = false }
 
-matrixmultiply = { version = "0.1.13" }
+matrixmultiply = { version = "0.2.0" }
 # Use via the `serde-1` crate feature!
 serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
-defmac = "0.1"
+defmac = "0.2"
+quickcheck = { version = "0.7.2", default-features = false }
 rawpointer = "0.1"
 
 [features]

LICENSE-MIT

@@ -1,4 +1,6 @@
-Copyright (c) 2015
+Copyright (c) 2015 - 2018 Ulrik Sverdrup "bluss",
+			  Jim Turner,
+			  and ndarray developers
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

README.rst

@@ -10,8 +10,8 @@ __ https://docs.rs/ndarray/
 
 |build_status|_ |crates|_
 
-.. |build_status| image:: https://api.travis-ci.org/bluss/ndarray.svg?branch=master
-.. _build_status: https://travis-ci.org/bluss/ndarray
+.. |build_status| image:: https://api.travis-ci.org/rust-ndarray/ndarray.svg?branch=master
+.. _build_status: https://travis-ci.org/rust-ndarray/ndarray
 
 .. |crates| image:: http://meritbadge.herokuapp.com/ndarray
 .. _crates: https://crates.io/crates/ndarray
@@ -70,7 +70,7 @@ How to use with cargo
 ::
 
     [dependencies]
-    ndarray = "0.11.0"
+    ndarray = "0.12.1"
 
 How to enable blas integration. Depend on ``blas-src`` directly to pick a blas
 provider. Depend on the same ``blas-src`` version as ``ndarray`` does, for the
@@ -80,14 +80,46 @@ provider::
 
 
     [dependencies]
-    ndarray = { version = "0.11.0", features = ["blas"] }
+    ndarray = { version = "0.12.1", features = ["blas"] }
     blas-src = { version = "0.2.0", default-features = false, features = ["openblas"] }
     openblas-src = { version = "0.6.0", default-features = false, features = ["cblas", "system"] }
 
 
 Recent Changes (ndarray)
 ------------------------
 
+- 0.12.1
+
+  - Add ``std_axis`` method for computing standard deviation by @LukeMathWalker.
+  - Add ``product`` method for computing product of elements in an array by @sebasv.
+  - Add ``first`` and ``first_mut`` methods for getting the first element of an array.
+  - Add ``into_scalar`` method for converting an ``Array0`` into its element.
+  - Add ``insert_axis_inplace`` and ``index_axis_inplace`` methods for inserting and
+    removing axes in dynamic-dimensional (``IxDyn``) arrays without taking ownership.
+  - Add ``stride_of`` method for getting the stride of an axis.
+  - Add public ``ndim`` and ``zeros`` methods to ``Dimension`` trait.
+  - Rename ``scalar_sum`` to ``sum``, ``subview`` to ``index_axis``,
+    ``subview_mut`` to ``index_axis_mut``, ``subview_inplace`` to
+    ``collapse_axis``, ``into_subview`` to ``index_axis_move``, and
+    ``slice_inplace`` to ``slice_collapse`` (deprecating the old names,
+    except for ``scalar_sum`` which will be in 0.13).
+  - Deprecate ``remove_axis`` and fix soundness hole when removing a zero-length axis.
+  - Implement ``Clone`` for ``LanesIter``.
+  - Implement ``Debug``, ``Copy``, and ``Clone`` for ``FoldWhile``.
+  - Relax constraints on ``sum_axis``, ``mean_axis``, and ``into_owned``.
+  - Add number of dimensions (and whether it's const or dynamic) to array ``Debug`` format.
+  - Allow merging axes with ``merge_axes`` when either axis length is ≤ 1.
+  - Clarify and check more precise safety requirements for constructing arrays.
+    This fixes undefined behavior in some edge cases. (See `#543`_.)
+  - Fix ``is_standard_layout`` in some edge cases. (See `#543`_.)
+  - Fix chunk sizes in ``axis_chunks_iter`` and ``axis_chunks_iter_mut`` when
+    the stride is zero or the array element type is zero-sized by @bluss.
+  - Improve documentation by @jturner314, @bluss, and @paulkernfeld.
+  - Improve element iterators with implementations of ``Iterator::rfold``.
+  - Miscellaneous internal implementation improvements by @jturner314 and @bluss.
+
+.. _`#543`: https://github.com/rust-ndarray/ndarray/pull/543
+
 - 0.12.0
 
   - Add ``var_axis`` method for computing variance by @LukeMathWalker.
@@ -164,7 +196,7 @@ __ https://docs.rs/ndarray/0.11/ndarray/doc/ndarray_for_numpy_users/
   - Minimum required Rust version is 1.22.
 
 __ https://jim.turner.link/pages/ndarray-0.11/
-.. _`#380`: https://github.com/bluss/rust-ndarray/pull/380
+.. _`#380`: https://github.com/rust-ndarray/ndarray/pull/380
 
 - 0.10.13
 
@@ -310,7 +342,7 @@ __ https://bluss.github.io//rust/2017/04/09/ndarray-0.9/
   - ``AxisChunksIter`` creation sped up and it implements ``Clone``.
   - Dimension mismatch in ``Zip`` has a better panic message.
 
-  __ https://bluss.github.io/rust-ndarray/master/ndarray/type.IxDyn.html
+  __ https://docs.rs/ndarray/0.8.2/ndarray/type.IxDyn.html
 
 - 0.8.1
 
@@ -634,7 +666,7 @@ __ http://bluss.github.io/rust/2016/03/06/ndarray-0.4/
   - Remove deprecated module ``linalg`` (it was already mostly empty)
   - Deprecate free function ``zeros`` in favour of static method ``zeros``.
 
-__ https://bluss.github.io/rust-ndarray/master/ndarray/struct.ArrayBase.html#arithmetic-operations
+__ https://docs.rs/ndarray/0.4.0-alpha.5/ndarray/struct.ArrayBase.html#arithmetic-operations
 
 - 0.4.0-alpha.4
 

benches/bench1.rs

@@ -2,7 +2,6 @@
 #![allow(unused_imports)]
 
 extern crate test;
-#[macro_use(s, azip)]
 extern crate ndarray;
 
 use ndarray::{
@@ -13,7 +12,7 @@ use ndarray::{
     Array2,
     Zip,
 };
-use ndarray::{arr0, arr1, arr2};
+use ndarray::{arr0, arr1, arr2, azip, s};
 use ndarray::ShapeBuilder;
 
 use test::black_box;
@@ -174,55 +173,55 @@ fn iter_sum_2d_transpose_by_row(bench: &mut test::Bencher)
 }
 
 #[bench]
-fn scalar_sum_2d_regular(bench: &mut test::Bencher)
+fn sum_2d_regular(bench: &mut test::Bencher)
 {
     let a = Array::<i32, _>::zeros((64, 64));
     let a = black_box(a);
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
 #[bench]
-fn scalar_sum_2d_cutout(bench: &mut test::Bencher)
+fn sum_2d_cutout(bench: &mut test::Bencher)
 {
     let a = Array::<i32, _>::zeros((66, 66));
     let av = a.slice(s![1..-1, 1..-1]);
     let a = black_box(av);
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
 #[bench]
-fn scalar_sum_2d_float(bench: &mut test::Bencher)
+fn sum_2d_float(bench: &mut test::Bencher)
 {
     let a = Array::<f32, _>::zeros((64, 64));
     let a = black_box(a.view());
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
 #[bench]
-fn scalar_sum_2d_float_cutout(bench: &mut test::Bencher)
+fn sum_2d_float_cutout(bench: &mut test::Bencher)
 {
     let a = Array::<f32, _>::zeros((66, 66));
     let av = a.slice(s![1..-1, 1..-1]);
     let a = black_box(av);
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 
 #[bench]
-fn scalar_sum_2d_float_t_cutout(bench: &mut test::Bencher)
+fn sum_2d_float_t_cutout(bench: &mut test::Bencher)
 {
     let a = Array::<f32, _>::zeros((66, 66));
     let av = a.slice(s![1..-1, 1..-1]).reversed_axes();
     let a = black_box(av);
     bench.iter(|| {
-        a.scalar_sum()
+        a.sum()
     });
 }
 

benches/chunks.rs

@@ -3,7 +3,6 @@
 extern crate test;
 use test::Bencher;
 
-#[macro_use(azip)]
 extern crate ndarray;
 use ndarray::prelude::*;
 use ndarray::NdProducer;
@@ -22,14 +21,14 @@ fn chunk2x2_iter_sum(bench: &mut Bencher)
 }
 
 #[bench]
-fn chunk2x2_scalar_sum(bench: &mut Bencher)
+fn chunk2x2_sum(bench: &mut Bencher)
 {
     let a = Array::<f32, _>::zeros((256, 256));
     let chunksz = (2, 2);
     let mut sum = Array::zeros(a.exact_chunks(chunksz).raw_dim());
     bench.iter(|| {
         azip!(ref a (a.exact_chunks(chunksz)), mut sum in {
-            *sum = a.scalar_sum();
+            *sum = a.sum();
         });
     });
 }

benches/construct.rs

@@ -3,7 +3,6 @@
 extern crate test;
 use test::Bencher;
 
-#[macro_use(s)]
 extern crate ndarray;
 use ndarray::prelude::*;
 

benches/higher-order.rs

@@ -5,7 +5,6 @@ extern crate test;
 use test::Bencher;
 use test::black_box;
 
-#[macro_use(s)]
 extern crate ndarray;
 use ndarray::prelude::*;
 

benches/iter.rs

@@ -6,10 +6,10 @@ use test::Bencher;
 use test::black_box;
 use rawpointer::PointerExt;
 
-#[macro_use(s, azip)]
 extern crate ndarray;
 use ndarray::prelude::*;
 use ndarray::{Zip, FoldWhile};
+use ndarray::Slice;
 
 #[bench]
 fn iter_sum_2d_regular(bench: &mut Bencher)
@@ -97,7 +97,7 @@ fn iter_filter_sum_2d_stride_f32(bench: &mut Bencher)
 const ZIPSZ: usize = 10_000;
 
 #[bench]
-fn scalar_sum_3_std_zip1(bench: &mut Bencher)
+fn sum_3_std_zip1(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -110,7 +110,7 @@ fn scalar_sum_3_std_zip1(bench: &mut Bencher)
 }
 
 #[bench]
-fn scalar_sum_3_std_zip2(bench: &mut Bencher)
+fn sum_3_std_zip2(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -123,7 +123,7 @@ fn scalar_sum_3_std_zip2(bench: &mut Bencher)
 }
 
 #[bench]
-fn scalar_sum_3_std_zip3(bench: &mut Bencher)
+fn sum_3_std_zip3(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -151,7 +151,7 @@ fn vector_sum_3_std_zip(bench: &mut Bencher)
 }
 
 #[bench]
-fn scalar_sum_3_azip(bench: &mut Bencher)
+fn sum_3_azip(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -166,7 +166,7 @@ fn scalar_sum_3_azip(bench: &mut Bencher)
 }
 
 #[bench]
-fn scalar_sum_3_azip_fold(bench: &mut Bencher)
+fn sum_3_azip_fold(bench: &mut Bencher)
 {
     let a = vec![1; ZIPSZ];
     let b = vec![1; ZIPSZ];
@@ -342,3 +342,51 @@ fn indexed_iter_3d_dyn(bench: &mut Bencher) {
         }
     })
 }
+
+#[bench]
+fn iter_sum_1d_strided_fold(bench: &mut Bencher)
+{
+    let mut a = Array::<u64, _>::ones(10240);
+    a.slice_axis_inplace(Axis(0), Slice::new(0, None, 2));
+    bench.iter(|| {
+        a.iter().fold(0, |acc, &x| acc + x)
+    });
+}
+
+#[bench]
+fn iter_sum_1d_strided_rfold(bench: &mut Bencher)
+{
+    let mut a = Array::<u64, _>::ones(10240);
+    a.slice_axis_inplace(Axis(0), Slice::new(0, None, 2));
+    bench.iter(|| {
+        a.iter().rfold(0, |acc, &x| acc + x)
+    });
+}
+
+
+#[bench]
+fn iter_axis_iter_sum(bench: &mut Bencher)
+{
+    let a = Array::<f32, _>::zeros((64, 64));
+    bench.iter(|| {
+        a.axis_iter(Axis(0)).map(|plane| plane.sum()).sum::<f32>()
+    });
+}
+
+#[bench]
+fn iter_axis_chunks_1_iter_sum(bench: &mut Bencher)
+{
+    let a = Array::<f32, _>::zeros((64, 64));
+    bench.iter(|| {
+        a.axis_chunks_iter(Axis(0), 1).map(|plane| plane.sum()).sum::<f32>()
+    });
+}
+
+#[bench]
+fn iter_axis_chunks_5_iter_sum(bench: &mut Bencher)
+{
+    let a = Array::<f32, _>::zeros((64, 64));
+    bench.iter(|| {
+        a.axis_chunks_iter(Axis(0), 5).map(|plane| plane.sum()).sum::<f32>()
+    });
+}