Added normalization feature for matrices and fixed issue where ValueArraySlice could not be converted property to a ValueArray

[Somnibyte]

I'm currently working on an implementation of Lasso Regression for a machine learning framework I'm working on and I stumbled upon an issue where UpSurge didn't have the ability to normalize my feature vectors. So I added the ability to normalize an entire matrix. I had stumbled upon an issue recently where whenever I tried to convert a ValueArraySlice to a ValueArray, the ValueArray class automatically adopts it's own step field rather than utilizing the original step field of the ValueArraySlice.

Here is an example:

let inputMatrix = Matrix<Float>(x)
let vectorSlice = inputMatrix .column(i)  // [3,4]
// The base of 'vectorSlice' is [3,5,8,4,12,15]

Now if I were to do the following I would get [3,5] instead of a ValueArray that has the elements 3,4 like the slice originally had:

let vectorSlice = ValueArray(inputMatrix .column(i)) // [3,5]
This is becuase within the ValueArray class the step size provided within the class, which is set to 1, is always adopted by this method:

Line 37 of ValueArray class:

    public var step: Index {
        return 1
    }

Problematic area (Line 88):

    /// Construct a ValueArray from contiguous memory
    public required init<C: LinearType where C.Element == Element>(_ values: C) {
        mutablePointer = UnsafeMutablePointer<Element>.alloc(values.count)
        capacity = values.count
        count = values.count
        values.withUnsafeBufferPointer { pointer in
            for i in 0..<count {
                mutablePointer[i] = pointer[values.startIndex + i * step]
            }
        }
    }

Above you see that in this line here, we are only using the step provided by the class. Instead we need the step provided by the ValueArraySlice (which in my example originally had a step of 3):

Original:
mutablePointer[i] = pointer[values.startIndex + i * step]

To fix this I use the 'values' parameters step field.

mutablePointer[i] = pointer[values.startIndex + i * values.step]

The normalize functions I implemented work as expected and have been tested.

[aidangomez]

Nice catch!

[Somnibyte]

Thanks @aidangomez! 😄

[alejandro-isaza]

Thanks 👍