protected override void Dispose(bool disposing)
 {
     if (library != null)
     {
         library.Dispose();
         library = null;
     }
 }
        public NativeOperatorRemotingCallbacks(string path)
        {
            library = new NativeLibraryRemoting(path);

            extension_info info;

            try {
                info = library.Invoke <get_extension_info_t, extension_info>("get_extension_info");
            } catch {
                library.Dispose();
                library = null;
                throw new InvalidOperationException();
            }

            if (info.library_name != IntPtr.Zero)
            {
                implementationName = library.ResolveStringAnsi(info.library_name);

                if (info.version_build != 0)
                {
                    implementationName += " v" + info.version_major + "." + info.version_minor + "." + info.version_build;
                }
                else if (info.version_major != 0 || info.version_minor != 0)
                {
                    implementationName += " v" + info.version_major + "." + info.version_minor;
                }

                if ((info.flags & extension_flags.AVX2) != 0)
                {
                    implementationName += " [AVX2]";
                }
                else if ((info.flags & extension_flags.AVX) != 0)
                {
                    implementationName += " [AVX]";
                }
                else if ((info.flags & extension_flags.SSE2) != 0)
                {
                    implementationName += " [SSE2]";
                }
                else if ((info.flags & extension_flags.SSE) != 0)
                {
                    implementationName += " [SSE]";
                }
            }
            else
            {
                implementationName = "Unknown";
            }

            List <string> missingCallbacksList = new List <string>();

            Constant e = null;

            Resolve(ref e, ConstantE, "constant_e", missingCallbacksList);
            if (e != null)
            {
                constant_e = e();
            }

            Constant pi = null;

            Resolve(ref pi, ConstantPi, "constant_pi", missingCallbacksList);
            if (pi != null)
            {
                constant_pi = pi();
            }

            Resolve(ref add, OperatorAdd, "operator_add", missingCallbacksList);
            Resolve(ref subtract, OperatorSubtract, "operator_subtract", missingCallbacksList);
            Resolve(ref multiply, OperatorMultiply, "operator_multiply", missingCallbacksList);
            Resolve(ref divide, OperatorDivide, "operator_divide", missingCallbacksList);
            Resolve(ref pow, OperatorPow, "operator_pow", missingCallbacksList);
            Resolve(ref remainder, OperatorRemainder, "operator_remainder", missingCallbacksList);

            Resolve(ref abs, OperatorAbs, "operator_abs", missingCallbacksList);
            Resolve(ref sqrt, OperatorSqrt, "operator_sqrt", missingCallbacksList);
            Resolve(ref exp, OperatorExp, "operator_exp", missingCallbacksList);
            Resolve(ref ln, OperatorLn, "operator_ln", missingCallbacksList);
            Resolve(ref log, OperatorLog, "operator_log", missingCallbacksList);
            Resolve(ref sin, OperatorSin, "operator_sin", missingCallbacksList);
            Resolve(ref cos, OperatorCos, "operator_cos", missingCallbacksList);
            Resolve(ref tan, OperatorTan, "operator_tan", missingCallbacksList);
            Resolve(ref asin, OperatorAsin, "operator_asin", missingCallbacksList);
            Resolve(ref acos, OperatorAcos, "operator_acos", missingCallbacksList);
            Resolve(ref atan, OperatorAtan, "operator_atan", missingCallbacksList);
            Resolve(ref sinh, OperatorSinh, "operator_sinh", missingCallbacksList);
            Resolve(ref cosh, OperatorCosh, "operator_cosh", missingCallbacksList);
            Resolve(ref tanh, OperatorTanh, "operator_tanh", missingCallbacksList);

            Resolve(ref round, OperatorRound, "operator_round", missingCallbacksList);
            Resolve(ref floor, OperatorFloor, "operator_floor", missingCallbacksList);
            Resolve(ref ceil, OperatorCeil, "operator_ceil", missingCallbacksList);

            missingCallbacks = missingCallbacksList.ToArray();
        }