(Dense)Tensor : Split operation

[NeusZimmer]

I just came to a need for splitting a DenseTensor file, to separate some outputs, while doint it came to a good ( i think ) split method able to work on any dimension and with any divisor, lacking some deep knowledge in c# i think there will be some ways to improve and make it faster, but i tried to avoid boxing and casting as much as possible ( at least on the possible big chunks of memory)... How does it looks? any feedback ?. I suppose it will be not hard to adapt for a normal tensor file.

public class DenseTensorOperations
{
        /// <summary>
        /// Flattens a tensor first dimension, returns X tensors as X=length of First dimension
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tensorToSplit"></param>
        /// <returns></returns>
        public static IEnumerable<DenseTensor<T>> SplitTensor<T>(DenseTensor<T> tensorToSplit)
        {
            int dimensionToSplit = 0; int divisor = 0;
            return private_SplitTensor(tensorToSplit, dimensionToSplit, divisor);
        }
        /// <summary>
        /// Split a tensor in a specific dimension, returns X tensors as X=length of that dimension 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tensorToSplit"></param>
        /// <param name="dimensionToSplit"></param>
        /// <returns></returns>
        public static IEnumerable<DenseTensor<T>> SplitTensor<T>(DenseTensor<T> tensorToSplit, int dimensionToSplit)
        {
            int divisor = 0;
            return private_SplitTensor(tensorToSplit, dimensionToSplit, divisor);
        }
        /// <summary>
        /// Split a tensor by a dimension divided by divisor parts, returns X tensors as X=(length/divisor) of that dimension 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tensorToSplit"></param>
        /// <param name="dimensionToSplit"></param>
        /// <param name="divisor"></param>
        /// <returns></returns>
        public static IEnumerable<DenseTensor<T>> SplitTensor<T>(DenseTensor<T> tensorToSplit, int dimensionToSplit = 0, int divisor = 0)
        {
            return private_SplitTensor(tensorToSplit, dimensionToSplit, divisor);
        }

private static IEnumerable<DenseTensor<T>> private_SplitTensor<T>(DenseTensor<T> tensorToSplit, int dimensionToSplit = 0, int divisor = 0)
{
            if (dimensionToSplit > tensorToSplit.Dimensions.ToArray().Length - 1) throw new ArgumentException("Selected a non-valid dimension");
            if (dimensionToSplit <0) throw new ArgumentException("Selected a non-valid dimension");

            int[] tensorDimensions = tensorToSplit.Dimensions.ToArray();
            int[] splitted_tensorDimensions = new int[tensorDimensions.Length];
            int step_size=1; 
            for (int i = 0; i < tensorDimensions.Length; i++)
            {
                if (i == dimensionToSplit)
                {
                    if (divisor == 0) splitted_tensorDimensions[i] = 1; //Flattens that dimension
                    else if (tensorDimensions[i] % divisor == 0) splitted_tensorDimensions[i] = tensorDimensions[i] / divisor;
                    else throw new ArgumentException("Is not possible to split the selected dimension by that divisor");
                    step_size = splitted_tensorDimensions[i];
                }
                else splitted_tensorDimensions[i] = tensorDimensions[i];
            }
            int size_of_splitted_tensors=1;
            foreach (int suma in splitted_tensorDimensions)
                size_of_splitted_tensors *= suma;

            
            int number_of_results = tensorDimensions[dimensionToSplit] / splitted_tensorDimensions[dimensionToSplit];
            T[][] temp_results = new T[number_of_results][]; 
            for (int i = 0; i < number_of_results; i++) temp_results[i] = new T[size_of_splitted_tensors];

            DenseTensor<T>[] results = new DenseTensor<T>[number_of_results]; 
            if (number_of_results > 1) //if not need to split , returns the original tensor
            {
                ReadOnlySpan<T> Span_tensorToSplit = tensorToSplit.Buffer.Span;
                int[] cloned_array = (int[])splitted_tensorDimensions.Clone();
                RecursiveSplitter(Span_tensorToSplit, tensorDimensions, cloned_array, ref temp_results, 0, step_size);
                for (int i = 0; i < number_of_results; i++)
                {
                    results[i] = new DenseTensor<T>(temp_results[i], splitted_tensorDimensions);
                }

            }
            else results[0] = tensorToSplit;

            return results;

}
private static T[][] get_splitted_dimension<T>(ReadOnlySpan<T> dimension, int pieces)
{
            T[][] result = new T[pieces][];
            int size_of_span = dimension.Length/pieces;

            T[] current_span = dimension.Slice(0, size_of_span).ToArray();
            result[0]=current_span;
            int pieces2 = pieces;
            if (pieces > 1)
            for (int i = 1; i < pieces; i++)
            {
                T[][] temp_list = get_splitted_dimension(dimension.Slice(size_of_span), pieces2 - 1);
                result[i] = temp_list[i-1];
            }

            return result;
        }
private static void RecursiveSplitter<T>(ReadOnlySpan<T> tensorToSplit, int[] dimensions1, int[] dimensions2, ref T[][] temp_results,int coord_X=0,int step_size=1)
{
    if (dimensions1[0]!= dimensions2[0]) //We reached the dimension to be splitted
    {
        int pieces = dimensions1[0]/dimensions2[0];
        var temp_list = get_splitted_dimension(tensorToSplit, pieces);
        for (int i = 0; i < pieces; i++)
            PasteResults(ref temp_results,ref temp_list[i],coord_X,i);
    }
    else
    {
        int total_calls = dimensions1[0];
        int size_of_span = tensorToSplit.Length / total_calls;

        int[] new_dimensions1 = new ArraySegment<int>(dimensions1,1, dimensions1.Length-1).ToArray(); 
        int[] new_dimensions2 = new ArraySegment<int>(dimensions2, 1, dimensions2.Length - 1).ToArray();
        var current_span = tensorToSplit.Slice(0, size_of_span);
        
        RecursiveSplitter(current_span, new_dimensions1, new_dimensions2, ref temp_results, coord_X, step_size);

        if (tensorToSplit.Length > size_of_span)
        {
            ReadOnlySpan<T> next_span = tensorToSplit.Slice(size_of_span);
            dimensions1[0] -= 1; 
            dimensions2[0] -= 1;
            RecursiveSplitter(next_span, dimensions1, dimensions2, ref temp_results, coord_X + step_size, step_size);
        }
    }
}
private static void PasteResults<T>(ref T[][]Array_results, ref T[]ArraytoPaste, int coord_X, int coord_Y)
{
    //check for different sizes??
    for (int i = 0; i < ArraytoPaste.Length; i++)
        Array_results[coord_Y][coord_X + i] = ArraytoPaste[i];
}