/// Vectorises a corpus using the hashing trick.

    /// Transforms the input into a sparse matrix of occurrences

        // TODO: normalisation
        CsMat::new_from_unsorted(

        let mut m = CsMat::new_from_unsorted(

        .unwrap()

        .unwrap();
        if self.normalise {
            for mut row in m.outer_iterator_mut() {
                row.unit_normalize();
            }
        }
        m

/// Sort and deduplicate the index and value arrays for a CSR matrix

    use ndarray::{array, Array, Axis};

    use ndarray::{array, Array};

    fn five_gram_test() {

    fn ngram_5() {

    fn vectorization_test() {

    fn vectorization_hashing_not_normalised() {

    fn tfidf_transformation_test() {

    fn vectorization_hashing_normalised() {
        let v = HashingVectorizer::new(16, 5, 5, true);
        let t = array![
            [
                0.,
                0.,
                -0.35355339,
                -0.35355339,
                0.35355339,
                0.,
                0.,
                -0.35355339,
                -0.35355339,
                0.,
                0.,
                -0.35355339,
                -0.35355339,
                0.,
                -0.35355339,
                0.
            ],
            [
                0.,
                0.24253563,
                -0.48507125,
                -0.48507125,
                0.24253563,
                0.24253563,
                0.,
                0.24253563,
                0.24253563,
                0.,
                -0.24253563,
                0.,
                -0.24253563,
                0.,
                -0.24253563,
                -0.24253563
            ],
            [
                -0.63245553,
                0.,
                0.,
                0.,
                0.31622777,
                0.31622777,
                0.,
                -0.31622777,
                0.,
                0.,
                0.,
                -0.31622777,
                0.,
                0.31622777,
                -0.31622777,
                0.
            ],
            [
                0.,
                0.,
                -0.70710678,
                -0.35355339,
                0.35355339,
                0.,
                0.,
                -0.35355339,
                -0.35355339,
                0.,
                0.,
                0.,
                0.,
                0.,
                0.,
                0.
            ]
        ];
        let mut r = v.fit_transform(&INPUT).to_dense();
        r.mapv_inplace(|v| round_dec(v, 8));
        assert_eq!(t, r);
    }
    #[test]
    fn tfidf_transformation() {