How to convert byte array containing float values to a double array in c#

I want to convert a byte array containing floats(4 bytes as a float) into a double array in the fastest way possible so I'm using blockcopy as internet suggested it. But , it seems like the values were not correct after the conversion into double can somebody help with!

public static void Test()
        {
            var floatArray = new float[] { 123.45f, 123f, 45f, 1.2f, 34.5f };
            // create a byte array and copy the floats into it...
            var byteArray = new byte[floatArray.Length * sizeof(float)];



            Buffer.BlockCopy(floatArray, 0, byteArray, 0, byteArray.Length);

            // create a double array and copy the bytes into it...
            var doubleArray = new double[byteArray.Length / 4];

            Buffer.BlockCopy(byteArray, 0, doubleArray, 0, byteArray.Length);
            // do we have the same sequence of floats that we started with?
            foreach(var i in doubleArray)
            {
                Console.WriteLine(i);
                // outputs -->   387028163194470.4 ,   0.02500000981399353 ,    5.474008307E-315 ,   0 ,   0
            }
        }

If you need speed, you're not going to get faster than this...

public static void Test()
{
	float val = 1024.24f;
	unsafe
	{
		// byte buffer
		Span<byte> bytes = stackalloc byte[Unsafe.SizeOf<double>()];

		// float to bytes
		fixed (byte* ptr = bytes) *((float*)ptr) = val;

		// bytes to double
		double dbl = default;
		fixed (byte* ptr = bytes) dbl = *((float*)ptr);
		
		// result
		Console.Write(dbl);
		
		//output: 1024.239990234375d == 1024.24f
	}	
}

See instructions below to understand what's happening on here - . The bytes are loaded onto the stack as a Float32, top of stack is converted to Float64, and then it's popped off the stack into into the local double at index 2...

Array.Copy() can convert from float to double.

Here is an example

static class Program
{
    static void Main(string[] args)
    {
        float[] f_arr = new float[] { 1.1111f, 22.22f, 333.3f };

        Console.WriteLine(string.Join(", ", f_arr));

        double[] d_arr = new double[f_arr.Length];

        Array.Copy(f_arr, d_arr, f_arr.Length);

        Console.WriteLine(string.Join(", ", d_arr));
    }
}

with output:

1.1111, 22.22, 333.3
1.1110999584198, 22.2199993133545, 333.299987792969

as you can see the precision is crap (since the 24 bit mantissa of float is assigned to the 53 bit mantissa of double). But it will do the trick without worrying about using byte arrays, and Buffer.Copy().