How to cast a generic array into another type?

Question

I'm still trying to find a fast way of how to convert a generic array of type TOutput to another array of type TInput. All my arrays are always of a numeric datatype, but since C# has no type constraint to Numeric as often requested, I currently have to live with this constraint. The suggested methods, like casting to an object before, seems to slow down my cast tremendously. Currently I have a large if/else construct that check for a type and cast to a defined type using pointer arithmetic, but this is way to large to handle for the future. Parallel.For seems a good way to get rid of pointers and to speed up thing, but still the C# generic constraints seem to be a problem, but still the Tout in the code below is a problem. Here's my code:

    public static OutputType[] Cast<InputType, OutputType>(InputType[] inputArray_in)
    {
        var aRange = Partitioner.Create(0, inputArray_in.Length);
        OutputType[] aResult = new OutputType[inputArray_in.Length];

        Parallel.ForEach(aRange, (r) =>
        {
            for (int i = r.Item1; i < r.Item2; i++)
            {
                aResult[i] = (OutputType)(inputArray_in[i]);
            }
        });

        return aResult;
    }

Example:

float[] A = { 0.1f, 0.2f, 0.6f };
int []B = Cast<float, int>(A);

In all cases my array types are numerical values (float, short, double,...) and most of the time, the arrays are about 512x512 images, but in a stack of about 1000 slices in a volume. Do you see any chance to have a simple way of performing this?

Test Code

public static class CastTest
{
    delegate double[] CastMethod(int[] input);

    public static unsafe double[] Cast1(int[] input)
    {
        int N = input.Length;
        double[] output = new double[N];

        for (int i = 0; i < N; i++) output[i] = (double)(input[i]);

        return output;
    }

    public static unsafe double[] Cast2(int[] input)
    {
        int N = input.Length;
        double[] output = new double[N];

        fixed (double* output_pinned = output)
        {
            double* outp = output_pinned;

            fixed (int* input_pinned = input)
            {
                int* inp = input_pinned;

                for (int i = 0; i < N; i++, inp++, outp++) *outp = (double)(*inp);
            }

            return output;
        }
    }

    public static unsafe double[] Cast3(int[] input)
    {
        int N = input.Length;
        double[] output = new double[N];

        fixed (double* output_pinned = output)
        {
            double* outp = output_pinned;

            fixed (int* input_pinned = input)
            {
                int* inp = input_pinned;

                for (int i = 0; i < N; i++) outp[i] = (double)(inp[i]);
            }

            return output;
        }
    }

    public static unsafe double[] Cast4(int[] input)
    {
        int N = input.Length;
        double[] output = new double[N];

        fixed (double* output_pinned = output)
        {
            fixed (int* input_pinned = input)
            {
                for (int i = 0; i < N; i++) output_pinned[i] = (double)(input_pinned[i]);
            }
        }

        return output;
    }

    public static unsafe double[] Cast5(int[] input)
    {
        return Array.ConvertAll<int, double>(input, x => (double)x);
    }

    public static double[] Cast6(int[] input)
    {
        var aRange = Partitioner.Create(0, input.Length);

        int N = input.Length;
        double[] output = new double[N];

        Parallel.ForEach(aRange, (r) =>
            {
                for (int i = r.Item1; i < r.Item2; i++) output[i] = (double)(input[i]);
            });

        return output;
    }

    public unsafe static double[] Cast7(int[] input)
    {
        var aRange = Partitioner.Create(0, input.Length);

        int N = input.Length;
        double[] output = new double[N];

        Parallel.ForEach(aRange, (r) =>
        {
            fixed (double* output_pinned = output)
            {
                double* outp = output_pinned + r.Item1;

                fixed (int* input_pinned = input)
                {
                    int* inp = input_pinned + r.Item1;

                    for (int i = r.Item1; i < r.Item2; i++, outp++, inp++) *outp = (double)(*inp);
                }
            }
        });

        return output;
    }

    public unsafe static double[] Cast8(int[] input)
    {
        var result = (from m in input.AsParallel() select (double)m).ToArray();

        return result;
    }


    public static double[] Cast9(int[] input)
    {
        return  (from m in input select (double)m).ToArray(); 
    }

    public static double[] Cast10(int[] input)
    {
        return (from m in input.AsParallel() select (double)m).ToArray(); 
    }

    public static double[] Cast11(int[] input)
    {
        return new List<double>(input.Select(p => (double)p)).ToArray(); 
    }

    static int[] A = new int[100000];
    const int runs = 10000;

    public static void StartTest()
    {
        TestMethod("1", Cast1);
        TestMethod("2", Cast2);
        TestMethod("3", Cast3);
        TestMethod("4", Cast4);
        TestMethod("5", Cast5);
        TestMethod("6", Cast6);
        TestMethod("7", Cast7);
        TestMethod("8", Cast8);
        TestMethod("9", Cast9);
        TestMethod("10", Cast10);
        TestMethod("11", Cast11);
    }

    static void TestMethod(string Name, CastMethod method)
    {
        var timer = Stopwatch.StartNew();

        for (int i = 0; i < runs; i++) { double[] res = method(A); }

        timer.Stop();

        Console.WriteLine(String.Format("{0}: {1}ms", Name, timer.ElapsedMilliseconds));
    }
}

Thank you Martin

Answer 1

I did three trivial experiments over a float array with 38988 items in it (I just cut and pasted a bunch of arbitrary values over and over again)

//_a = array of floats


// pretty standard way of doing it 4ms
_result = (from m in _a select (int)m).ToArray();

// I was rather disappointed with this 35ms
_result = (from m in _a.AsParallel() select (int)m).ToArray();

// using a list rather surprised me 1ms
_result = new List<int>(_a.Select(p => (int)p)).ToArray();

so I don't know how these compare with your tests but I'd say selecting into the generic list is pretty effective.

EDIT:

I'm adding my code. I must be missing something because I get quite different results from my example as compared to running your example.

class Program
{
    static void Main(string[] args)
    {

        using (var x = new ArrayCast())
        {
            x.Run();
        } 

        using (var x = new ArrayCastList())
        {
            x.Run();
        }
        using (var x = new ArrayCastAsParallel())
        {
            x.Run();
        }

        while (Console.Read() != 'q')
        {
            ;    // do nothing...
        }
    }
}

public abstract class Experiment : IAmATest, IDisposable
{
    private Stopwatch _timer;


    protected bool IgnoreAssert { get; set; }

    #region IAmATest Members

    public abstract void Arrange();
    public abstract void Act();
    public abstract void Assert();

    #endregion

    public void Run()
    {
        _timer = Stopwatch.StartNew();
        Arrange();
        _timer.Stop();

        Console.WriteLine(String.Join(":", "Arrange", _timer.ElapsedMilliseconds));

        _timer = Stopwatch.StartNew();
        for (int i = 1; i < 1000; i++)
        Act();
        _timer.Stop();

        Console.WriteLine(String.Join(":", "Act", _timer.ElapsedMilliseconds));

        if (IgnoreAssert) { return; }

        _timer = Stopwatch.StartNew();
        Assert();
        _timer.Stop();

        Console.WriteLine(String.Join(":", "Assert", _timer.ElapsedMilliseconds));
    }

    public abstract void Dispose();
}

public class ArrayCast : Experiment
{
    private int[] _a;
    double[] _result;

    public override void Arrange()
    {
        IgnoreAssert = true;
        _a = new int[100000];
    }

    public override void Act()
    {
            _result = (from m in _a select (double)m).ToArray();
    }

    public override void Assert() { }

    public override void Dispose() { _a = null; }
}

public class ArrayCastAsParallel : Experiment
{
    private int[] _a;
    double[] _result;

    public override void Arrange()
    {
        IgnoreAssert = true;
        _a = new int[100000];
    }

    public override void Act()
    {
        _result = (from m in _a.AsParallel() select (double)m).ToArray();
    }

    public override void Assert() { }

    public override void Dispose() { _a = null; }
}

public class ArrayCastList : Experiment
{
    private int[] _a;
    double[] _result;

    public override void Arrange()
    {
        IgnoreAssert = true;
        _a = new int[100000];
    }

    public override void Act()
    {
        var x = new List<double>(_a.Select(p => (double)p));
    }

    public override void Assert() { }

    public override void Dispose() { _a = null; }
}

Answer 2

Why don't you use simply Cast for lists, it's LINQ Cast method member of System.Linq.Enumerable :

float[] A = { 0.1f, 0.2f, 0.6f };
int[] B = A.Cast(Of int).ToArray();

You can read about it here : Enumerable.Cast(Of TResult) Method

Answer 3

There is no magic conversion (when using generics etc) between numeric types like this; there are tricks like Convert.ChangeType, or dynamic, but both involve an intermediate box/unbox.

Personally, I'd just be using:

float[] A = { 0.1f, 0.2f, 0.6f };
int[] B = Array.ConvertAll(A, x => (int)x);

This offloads the conversion logic to the compiler (to use the correct conversion from float to int without intermediaries or reflection). It is, however, not usable inside generics - i.e. x => (OutputType)x will not work.

Answer 4

Did you try this?

public static TOut[] Cast<TOut,TIn>(TIn[] arr) {
        return arr.Select(x => (TOut)Convert.ChangeType(x,typeof(TOut))).ToArray();
}