conv deconv, C# - rextester

Language: Layout:

/*
With help from code at http://rextester.com/JUQV98357

This program performs small convolutions (and perhaps deconvolutions) very efficiently,
with a single (Int64 * Int64) instruction being used to perform
an entire (4 Int16 with 4 Int16) or (8 byte with 8 byte) convolution.
*/

using System;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var A = new byte[]{1, 2, 3, 4, 5, 6, 7, 8};
            var a = combine_to_Int64(A);
            var B = new byte[]{1, 2, 3, 4, 5, 6, 7, 8};
            var b = combine_to_Int64(B);
            var c = a * b;
            var C = seperate_to_8_byte(c);
            var d = deconvolution(c, b); // not correct
            var D = seperate_to_8_byte(d);
            Console.WriteLine(
                "The convolution of (" + to_string(A) + ") with ("+ to_string(B) +") is: (" +
                to_string(C) + ")");
            Console.WriteLine(
                "The deconvolution of (" + to_string(C) + ") with ("+ to_string(B) +") is: (" +
                to_string(D) + ")");
        }
        
        public static string to_string(byte[] values)
        {
            string s = "";
            foreach (var val in values)
                s += (s == "" ? "" : " ") + val;
            return s;
        }
        
        public static string to_string(Int16[] values)
        {
            string s = "";
            foreach (var val in values)
                s += (s == "" ? "" : " ") + val;
            return s;
        }
        
        public static Int64 convolution(Int64 a, Int64 b)
        {
            return a * b;
        }
        
        public static Int64 deconvolution(Int64 a, Int64 b)
        {
            var large = System.Numerics.BigInteger.Parse("1000000000000000000000000000000");
            return (Int64)((((
                new System.Numerics.BigInteger(a)
                * large)
                / new System.Numerics.BigInteger(b))
                * 72057594037927936)
                / large);
        }
        
        private static Int64 combine_to_Int64(byte[] n)
        {
            if (n.Length == 4)
                return n[0] + 65536 * n[1] + 4294967296 * n[2] + 281474976710656 * n[3];
            else if (n.Length == 8)
                return n[0] + 256 * n[1] + 65536 * n[2] + 16777216 * n[3] + 4294967296 *
                    n[4] + 1099511627776 * n[5] + 281474976710656 * n[6] + 72057594037927936 * n[7];
            else
                throw new ArgumentException();
        }
        
        private static Int16[] seperate_to_4_Int16(Int64 a)
        {
            return new []{(Int16) a, (Int16) (a >> 0x10),
                (Int16) (a >> 0x20), (Int16) (a >> 0x30)};
        }
        
        private static byte[] seperate_to_8_byte(Int64 a)
        {
            return new []{(byte) a, (byte) (a >> 8), (byte) (a >> 0x10),
                (byte) (a >> 0x18), (byte) (a >> 0x20), (byte) (a >> 0x28),
                (byte) (a >> 0x30), (byte) (a >> 0x38)};
        }
    }
}

Show compiler warnings [ + ] Show input
Compilation time: 0,16 sec, absolute running time: 0,09 sec, cpu time: 0,08 sec, average memory usage: 14 Mb, average nr of threads: 3