Split AsTargets into AsSingleTargets and AsMultiTargets

src/dataset/impl_dataset.rs

@@ -1,8 +1,8 @@
 use super::{
     super::traits::{Predict, PredictInplace},
     iter::{ChunksIter, DatasetIter, Iter},
-    AsTargets, AsTargetsMut, CountedTargets, Dataset, DatasetBase, DatasetView, Float,
-    FromTargetArray, Label, Labels, Records, Result,
+    AsMultiTargets, AsMultiTargetsMut, AsSingleTargets, AsSingleTargetsMut, CountedTargets,
+    Dataset, DatasetBase, DatasetView, Float, FromTargetArray, Label, Labels, Records, Result,
 };
 use crate::traits::Fit;
 use ndarray::{
@@ -123,7 +123,7 @@ impl<R: Records, S> DatasetBase<R, S> {
     }
 }
 
-impl<L, R: Records, T: AsTargets<Elem = L>> DatasetBase<R, T> {
+impl<L, R: Records, T: AsSingleTargets<Elem = L>> DatasetBase<R, T> {
     /// Map targets with a function `f`
     ///
     /// # Example

src/dataset/impl_targets.rs

@@ -1,22 +1,54 @@
 use std::collections::HashMap;
 
 use super::{
-    AsProbabilities, AsTargets, AsTargetsMut, CountedTargets, DatasetBase, FromTargetArray, Label,
-    Labels, Pr, Records,
+    AsMultiTargets, AsMultiTargetsMut, AsProbabilities, AsSingleTargets, AsSingleTargetsMut,
+    CountedTargets, DatasetBase, FromTargetArray, Label, Labels, Pr, Records,
 };
 use ndarray::{
     Array1, Array2, ArrayBase, ArrayView2, ArrayViewMut2, Axis, CowArray, Data, DataMut, Dimension,
     Ix1, Ix2, Ix3, OwnedRepr, ViewRepr,
 };
 
-impl<'a, L, S: Data<Elem = L>> AsTargets for ArrayBase<S, Ix1> {
+impl<'a, L, S: Data<Elem = L>> AsSingleTargets for ArrayBase<S, Ix1> {
     type Elem = L;
 
     fn as_multi_targets(&self) -> ArrayView2<L> {
         self.view().insert_axis(Axis(1))
     }
 }
 
+impl<'a, L, S: Data<Elem = L>> AsSingleTargets for ArrayBase<S, Ix2> {
+    type Elem = L;
+
+    fn as_multi_targets(&self) -> ArrayView2<L> {
+        self.view()
+    }
+}
+
+impl<'a, L, S: Data<Elem = L>> AsMultiTargets for ArrayBase<S, Ix1> {
+    type Elem = L;
+
+    fn as_multi_targets(&self) -> ArrayView2<L> {
+        self.view().insert_axis(Axis(1))
+    }
+
+    fn ntargets(&self) -> usize {
+        1
+    }
+}
+
+impl<'a, L, S: Data<Elem = L>> AsMultiTargets for ArrayBase<S, Ix2> {
+    type Elem = L;
+
+    fn as_multi_targets(&self) -> ArrayView2<L> {
+        self.view()
+    }
+
+    fn ntargets(&self) -> usize {
+        self.len_of(Axis(1))
+    }
+}
+
 impl<'a, L: Clone + 'a, S: Data<Elem = L>> FromTargetArray<'a, L> for ArrayBase<S, Ix2> {
     type Owned = ArrayBase<OwnedRepr<L>, Ix2>;
     type View = ArrayBase<ViewRepr<&'a L>, Ix2>;
@@ -30,57 +62,109 @@ impl<'a, L: Clone + 'a, S: Data<Elem = L>> FromTargetArray<'a, L> for ArrayBase<
     }
 }
 
-impl<L, S: DataMut<Elem = L>> AsTargetsMut for ArrayBase<S, Ix1> {
+impl<L, S: DataMut<Elem = L>> AsSingleTargetsMut for ArrayBase<S, Ix1> {
     type Elem = L;
 
     fn as_multi_targets_mut(&mut self) -> ArrayViewMut2<'_, Self::Elem> {
         self.view_mut().insert_axis(Axis(1))
     }
 }
 
-impl<L, S: Data<Elem = L>> AsTargets for ArrayBase<S, Ix2> {
+impl<L, S: DataMut<Elem = L>> AsSingleTargetsMut for ArrayBase<S, Ix2> {
     type Elem = L;
 
-    fn as_multi_targets(&self) -> ArrayView2<L> {
-        self.view()
+    fn as_multi_targets_mut(&mut self) -> ArrayViewMut2<'_, Self::Elem> {
+        self.view_mut()
     }
 }
 
-impl<L, S: DataMut<Elem = L>> AsTargetsMut for ArrayBase<S, Ix2> {
+impl<L, S: DataMut<Elem = L>> AsMultiTargetsMut for ArrayBase<S, Ix1> {
+    type Elem = L;
+
+    fn as_multi_targets_mut(&mut self) -> ArrayViewMut2<'_, Self::Elem> {
+        self.view_mut().insert_axis(Axis(1))
+    }
+
+    fn ntargets(&self) -> usize {
+        1
+    }
+}
+
+impl<L, S: DataMut<Elem = L>> AsMultiTargetsMut for ArrayBase<S, Ix2> {
     type Elem = L;
 
     fn as_multi_targets_mut(&mut self) -> ArrayViewMut2<'_, Self::Elem> {
         self.view_mut()
     }
+
+    fn ntargets(&self) -> usize {
+        self.len_of(Axis(1))
+    }
 }
 
-impl<T: AsTargets> AsTargets for &T {
+impl<T: AsSingleTargets> AsSingleTargets for &T {
     type Elem = T::Elem;
 
     fn as_multi_targets(&self) -> ArrayView2<Self::Elem> {
         (*self).as_multi_targets()
     }
 }
 
-impl<L: Label, T: AsTargets<Elem = L>> AsTargets for CountedTargets<L, T> {
+impl<T: AsMultiTargets> AsMultiTargets for &T {
+    type Elem = T::Elem;
+
+    fn as_multi_targets(&self) -> ArrayView2<Self::Elem> {
+        (*self).as_multi_targets()
+    }
+
+    fn ntargets(&self) -> usize {
+        (*self).ntargets()
+    }
+}
+
+impl<L: Label, T: AsSingleTargets<Elem = L>> AsSingleTargets for CountedTargets<L, T> {
     type Elem = L;
 
     fn as_multi_targets(&self) -> ArrayView2<L> {
         self.targets.as_multi_targets()
     }
 }
 
-impl<L: Label, T: AsTargetsMut<Elem = L>> AsTargetsMut for CountedTargets<L, T> {
+impl<L: Label, T: AsMultiTargets<Elem = L>> AsMultiTargets for CountedTargets<L, T> {
+    type Elem = L;
+
+    fn as_multi_targets(&self) -> ArrayView2<Self::Elem> {
+        self.targets.as_multi_targets()
+    }
+
+    fn ntargets(&self) -> usize {
+        self.targets.ntargets()
+    }
+}
+
+impl<L: Label, T: AsSingleTargetsMut<Elem = L>> AsSingleTargetsMut for CountedTargets<L, T> {
+    type Elem = L;
+
+    fn as_multi_targets_mut(&mut self) -> ArrayViewMut2<'_, Self::Elem> {
+        self.targets.as_multi_targets_mut()
+    }
+}
+
+impl<L: Label, T: AsMultiTargetsMut<Elem = L>> AsMultiTargetsMut for CountedTargets<L, T> {
     type Elem = L;
 
     fn as_multi_targets_mut(&mut self) -> ArrayViewMut2<'_, Self::Elem> {
         self.targets.as_multi_targets_mut()
     }
+
+    fn ntargets(&self) -> usize {
+        self.targets.ntargets()
+    }
 }
 
 impl<'a, L: Label + 'a, T> FromTargetArray<'a, L> for CountedTargets<L, T>
 where
-    T: AsTargets<Elem = L> + FromTargetArray<'a, L>,
+    T: AsSingleTargets<Elem = L> + FromTargetArray<'a, L>,
     T::Owned: Labels<Elem = L>,
     T::View: Labels<Elem = L>,
 {
@@ -152,7 +236,7 @@ impl<L: Label, S: Data<Elem = L>, I: Dimension> Labels for ArrayBase<S, I> {
 }
 
 /// Counted labels can act as labels
-impl<L: Label, T: AsTargets<Elem = L>> Labels for CountedTargets<L, T> {
+impl<L: Label, T: AsSingleTargets<Elem = L>> Labels for CountedTargets<L, T> {
     type Elem = L;
 
     fn label_count(&self) -> Vec<HashMap<L, usize>> {
@@ -163,7 +247,7 @@ impl<L: Label, T: AsTargets<Elem = L>> Labels for CountedTargets<L, T> {
 impl<F: Copy, L: Copy + Label, D, T> DatasetBase<ArrayBase<D, Ix2>, T>
 where
     D: Data<Elem = F>,
-    T: AsTargets<Elem = L>,
+    T: AsSingleTargets<Elem = L>,
 {
     /// Transforms the input dataset by keeping only those samples whose label appears in `labels`.
     ///

src/dataset/iter.rs

@@ -1,4 +1,4 @@
-use super::{AsTargets, DatasetBase, DatasetView, FromTargetArray, Records};
+use super::{AsMultiTargets, AsSingleTargets, DatasetBase, DatasetView, FromTargetArray, Records};
 use ndarray::{s, ArrayBase, ArrayView1, ArrayView2, Axis, Data, Ix2};
 use std::marker::PhantomData;
 
@@ -63,7 +63,7 @@ impl<'a, 'b: 'a, R: Records, T> DatasetIter<'a, 'b, R, T> {
 impl<'a, 'b: 'a, F: 'a, L: 'a, D, T> Iterator for DatasetIter<'a, 'b, ArrayBase<D, Ix2>, T>
 where
     D: Data<Elem = F>,
-    T: AsTargets<Elem = L> + FromTargetArray<'a, L>,
+    T: AsMultiTargets<Elem = L> + FromTargetArray<'a, L>,
 {
     type Item = DatasetView<'a, F, L>;
 
@@ -136,7 +136,7 @@ impl<'a, 'b: 'a, F, T> ChunksIter<'a, 'b, F, T> {
 
 impl<'a, 'b: 'a, F, E: 'b, T> Iterator for ChunksIter<'a, 'b, F, T>
 where
-    T: AsTargets<Elem = E> + FromTargetArray<'b, E>,
+    T: AsMultiTargets<Elem = E> + FromTargetArray<'b, E>,
 {
     type Item = DatasetBase<ArrayView2<'a, F>, T::View>;
 

src/dataset/mod.rs

@@ -198,8 +198,8 @@ pub trait Records: Sized {
     fn nfeatures(&self) -> usize;
 }
 
-/// Return a reference to single or multiple target variables
-pub trait AsTargets {
+/// Return a reference to single target variable
+pub trait AsSingleTargets {
     type Elem;
 
     /// Returns a view on targets as two-dimensional array
@@ -222,6 +222,17 @@ pub trait AsTargets {
     }
 }
 
+/// Return a reference to a multi-target variable
+pub trait AsMultiTargets {
+    type Elem;
+
+    /// Convert to a multi-target
+    fn as_multi_targets(&self) -> ArrayView2<Self::Elem>;
+
+    /// Returns the number of targets
+    fn ntargets(&self) -> usize;
+}
+
 /// Helper trait to construct counted labels
 ///
 /// This is implemented for objects which can act as targets and created from a target matrix. For
@@ -236,7 +247,7 @@ pub trait FromTargetArray<'a, F> {
     fn new_targets_view(targets: ArrayView2<'a, F>) -> Self::View;
 }
 
-pub trait AsTargetsMut {
+pub trait AsSingleTargetsMut {
     type Elem;
 
     /// Returns a mutable view on targets as two-dimensional array
@@ -254,6 +265,16 @@ pub trait AsTargetsMut {
     }
 }
 
+pub trait AsMultiTargetsMut {
+    type Elem;
+
+    /// Convert to a multi-target
+    fn as_multi_targets_mut(&mut self) -> Result<ArrayViewMut2<Self::Elem>>;
+
+    /// Returns the number of targets
+    fn ntargets(&self) -> usize;
+}
+
 /// Convert to probability matrix
 ///
 /// Some algorithms are working with probabilities. Targets which allow an implicit conversion into

src/metrics_classification.rs

@@ -9,7 +9,7 @@ use std::fmt;
 use ndarray::prelude::*;
 use ndarray::Data;
 
-use crate::dataset::{AsTargets, DatasetBase, Label, Labels, Pr, Records};
+use crate::dataset::{AsSingleTargets, DatasetBase, Label, Labels, Pr, Records};
 use crate::error::{Error, Result};
 
 /// Return tuple of class index for each element of prediction and ground_truth
@@ -264,7 +264,7 @@ pub trait ToConfusionMatrix<A, T> {
 impl<L: Label, S, T> ToConfusionMatrix<L, ArrayBase<S, Ix1>> for T
 where
     S: Data<Elem = L>,
-    T: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
     fn confusion_matrix(&self, ground_truth: ArrayBase<S, Ix1>) -> Result<ConfusionMatrix<L>> {
         self.confusion_matrix(&ground_truth)
@@ -274,7 +274,7 @@ where
 impl<L: Label, S, T> ToConfusionMatrix<L, &ArrayBase<S, Ix1>> for T
 where
     S: Data<Elem = L>,
-    T: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
     fn confusion_matrix(&self, ground_truth: &ArrayBase<S, Ix1>) -> Result<ConfusionMatrix<L>> {
         let targets = self.try_single_target()?;
@@ -307,16 +307,16 @@ impl<L: Label, R, R2, T, T2> ToConfusionMatrix<L, &DatasetBase<R, T>> for Datase
 where
     R: Records,
     R2: Records,
-    T: AsTargets<Elem = L>,
-    T2: AsTargets<Elem = L> + Labels<Elem = L>,
+    T: AsSingleTargets<Elem = L>,
+    T2: AsSingleTargets<Elem = L> + Labels<Elem = L>,
 {
     fn confusion_matrix(&self, ground_truth: &DatasetBase<R, T>) -> Result<ConfusionMatrix<L>> {
         self.targets()
             .confusion_matrix(ground_truth.try_single_target()?)
     }
 }
 
-impl<L: Label, S: Data<Elem = L>, T: AsTargets<Elem = L> + Labels<Elem = L>, R: Records>
+impl<L: Label, S: Data<Elem = L>, T: AsSingleTargets<Elem = L> + Labels<Elem = L>, R: Records>
     ToConfusionMatrix<L, &DatasetBase<R, T>> for ArrayBase<S, Ix1>
 {
     fn confusion_matrix(&self, ground_truth: &DatasetBase<R, T>) -> Result<ConfusionMatrix<L>> {
@@ -477,7 +477,7 @@ impl<D: Data<Elem = Pr>> BinaryClassification<&[bool]> for ArrayBase<D, Ix1> {
     }
 }
 
-impl<R: Records, R2: Records, T: AsTargets<Elem = bool>, T2: AsTargets<Elem = Pr>>
+impl<R: Records, R2: Records, T: AsSingleTargets<Elem = bool>, T2: AsSingleTargets<Elem = Pr>>
     BinaryClassification<&DatasetBase<R, T>> for DatasetBase<R2, T2>
 {
     fn roc(&self, y: &DatasetBase<R, T>) -> Result<ReceiverOperatingCharacteristic> {

src/metrics_clustering.rs

@@ -1,5 +1,5 @@
 //! Common metrics for clustering
-use crate::dataset::{AsTargets, DatasetBase, Label, Labels, Records};
+use crate::dataset::{AsSingleTargets, DatasetBase, Label, Labels, Records};
 use crate::error::{Error, Result};
 use crate::Float;
 use ndarray::{ArrayBase, ArrayView1, Data, Ix2};
@@ -62,8 +62,13 @@ impl<F: Float> DistanceCount<F> {
     }
 }
 
-impl<'a, F: Float, L: 'a + Label, D: Data<Elem = F>, T: AsTargets<Elem = L> + Labels<Elem = L>>
-    SilhouetteScore<F> for DatasetBase<ArrayBase<D, Ix2>, T>
+impl<
+        'a,
+        F: Float,
+        L: 'a + Label,
+        D: Data<Elem = F>,
+        T: AsSingleTargets<Elem = L> + Labels<Elem = L>,
+    > SilhouetteScore<F> for DatasetBase<ArrayBase<D, Ix2>, T>
 {
     fn silhouette_score(&self) -> Result<F> {
         if self.ntargets() > 1 {