ICalculator<T> 
{ 
    T Add(T left, T right);
    T Subtract(T left, T right);
    T Multiply(T left, T right);
    T Divide(T left, T right);
}

struct Vector<T>
{
    private static readonly ICalculator<T> calculator;

    static Vector()
    {
         Vector<T>.calculator = CalculatorGenerator.Generate<T>();
    }

    static Vector<T> Add(Vector<T> left, Vector<T> right)
    {
        ...
        sum[i] = calculator.Add(left[i], right[i]);
        ...
    }
}

        public static ICalculator<T> Generate<T>()
        {
            string typeName = String.Concat("__CalculatorOf", typeof(T).Name);
            CodeCompileUnit compileUnit = new CodeCompileUnit
            {
                ReferencedAssemblies = 
                {
                    "Calculator.dll"
                },
                Namespaces =
                {
                    new CodeNamespace
                    {
                        Name = "CalculatorNamespace",
                        Types =
                        {
                            new CodeTypeDeclaration
                            {
                                Name = typeName,
                                BaseTypes = { typeof(ICalculator<T>) },
                                Members =
                                {
                                    CalculatorGenerator.CreateMethod<T>("Add", CodeBinaryOperatorType.Add),
                                    CalculatorGenerator.CreateMethod<T>("Subtract", CodeBinaryOperatorType.Subtract),
                                    CalculatorGenerator.CreateMethod<T>("Multiply", CodeBinaryOperatorType.Multiply),
                                    CalculatorGenerator.CreateMethod<T>("Divide", CodeBinaryOperatorType.Divide)
                                }
                            }
                        }
                    }
                }
            };

            CSharpCodeProvider provider = new CSharpCodeProvider();
            CompilerResults results = provider.CompileAssemblyFromDom(new CompilerParameters { }, compileUnit);
            Type calculatorType = results.CompiledAssembly.GetType(String.Concat("CalculatorNamespace.", typeName));
            return (ICalculator<T>)Activator.CreateInstance(calculatorType);
        }

        private static CodeMemberMethod CreateMethod<T>(string name, CodeBinaryOperatorType operatorType)
        {
            return new CodeMemberMethod
            {
                Name = name,
                Attributes = MemberAttributes.Public,
                ReturnType = new CodeTypeReference(typeof(T)),
                Parameters =
                {
                    new CodeParameterDeclarationExpression(typeof(T), "left"),
                    new CodeParameterDeclarationExpression(typeof(T), "right")
                },
                Statements =
                {
                    new CodeMethodReturnStatement(
                        new CodeBinaryOperatorExpression(
                            new CodeVariableReferenceExpression("left"), 
                            operatorType, 
                            new CodeVariableReferenceExpression("right")))
                }
            };
        }