Click here to Skip to main content
Click here to Skip to main content
Articles » Languages » C++ / CLI » C++/CLI » Downloads
 
Add your own
alternative version

CLinq - LINQ support for the C++/CLI language

, 27 Jul 2007 Ms-PL
CLinq project is a library that makes it possible to use LINQ technologies from the C++/CLI language
clinq-demo.zip
bin
clinqgen.exe
EeekSoft.CLinq.dll
demo
app.ico
Debug
include
clinq-doc.zip
class.png
method.png
operator.png
property.png
static.png
clinq-src.zip
Debug
EeekSoft.CLinq
app.ico
EeekSoft.CLinq.vcproj.RINCEWIND.Tomas.user
EeekSoft.CLinq.vcproj.vspscc
EeekSoft.CLinq.CodeGen
app.ico
EeekSoft.CLinq.CodeGen.vcproj.RINCEWIND.Tomas.user
EeekSoft.CLinq.CodeGen.vcproj.vspscc
EeekSoft.CLinq.Demo
app.ico
EeekSoft.CLinq.Demo.vcproj.RINCEWIND.Tomas.user
EeekSoft.CLinq.Demo.vcproj.vspscc
EeekSoft.CLinq.Includes
Doc
class.png
method.png
operator.png
property.png
static.png
EeekSoft.CLinq.Includes.vcproj.rincewind.Tomas.user
EeekSoft.CLinq.Includes.vcproj.vspscc
EeekSoft.CLinq.Typed.xsl
EeekSoft.CLinq.TypedDoc.xsl
EeekSoft.CLinq.XsltUtil
app.aps
app.ico
EeekSoft.CLinq.XsltUtil.vcproj.RINCEWIND.Tomas.user
EeekSoft.CLinq.XsltUtil.vcproj.vspscc
CLinq.suo
CLinq.vssscc
/*****************************************************************************/
/** DO NOT MODIFY THIS FILE                                                 **/
/** generated using xsl transformation: EeekSoft.CLinq.Typed.xsl            **/
/*****************************************************************************/
#pragma once
#include "clinqcore.h"

using namespace System;
using namespace System::Reflection;
using namespace System::Collections::Generic;
using namespace EeekSoft::CLinq;

namespace EeekSoft {
	namespace CLinq {
    /// <summary>
    /// Template specialization for the 'bool' expresion. Implements operators !=, == and logical operators (&amp;&amp;, ||) and unary !.
    /// </summary>
    template<> public ref class Expr<bool> : ExpressionWrapper<bool>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return bool::typeid; } }
    
		public:
			Expr<bool>() { }
      Expr<bool>(bool val) { _value = gcnew Literal<bool>(val); }
      Expr<bool>(Expression<bool>^ value) { _value = value; }
			Expr<bool>(Expr<bool>% b)	{ _value = b._value; }
			operator Expression<bool>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<bool>(Expression<bool>^ value)  { return Expr<bool>(value); }
			static operator Expr<bool>(bool b) { return Expr<bool>(b); }
      
      

    public:
    static Expr<bool> Typed(GenericExpression^ value) 
      { 
        return Expr<bool>(gcnew TypedExpression<bool>(value));
      }

      static Expr<bool> Convert(GenericExpression^ value) 
      { 
        return Expr<bool>(gcnew ConvertExpression<bool>(value));
      }

    public:
      
      /// <summary>
      /// Returns negation of the logical value.
      /// </summary>
      static Expr<bool> operator!(Expr<bool> value)
      {
        return Expr<bool>(gcnew UnaryExpression<bool,bool>
          (value, System::Expressions::ExpressionType::Not));
      }

      /// <summary>
      /// Test values for equality.
      /// </summary>
      static Expr<bool> operator==(Expr<bool> left, Expr<bool> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,bool,bool>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Test values for inequality.
      /// </summary>
      static Expr<bool> operator!=(Expr<bool> left, Expr<bool> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,bool,bool>
          (left, right, System::Expressions::ExpressionType::NE));
      }

      /// <summary>
      /// Performs logical 'and' operation.
      /// </summary>
      static Expr<bool> operator&&(Expr<bool> left, Expr<bool> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,bool,bool>
          (left, right, System::Expressions::ExpressionType::And));
      }

      /// <summary>
      /// Performs logical 'or' operation.
      /// </summary>
      static Expr<bool> operator||(Expr<bool> left, Expr<bool> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,bool,bool>
          (left, right, System::Expressions::ExpressionType::Or));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<double>' expresion. Supports standard math and comparison operators.
    /// </summary>
    template<> public ref class Expr<Nullable<double>> : ExpressionWrapper<Nullable<double>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<double>::typeid; } }
    
		public:
			Expr<Nullable<double>>() { }
      Expr<Nullable<double>>(Nullable<double> val) { _value = gcnew Literal<Nullable<double>>(val); }
      Expr<Nullable<double>>(Expression<Nullable<double>>^ value) { _value = value; }
			Expr<Nullable<double>>(Expr<Nullable<double>>% b)	{ _value = b._value; }
			operator Expression<Nullable<double>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<double>>(Expression<Nullable<double>>^ value)  { return Expr<Nullable<double>>(value); }
			static operator Expr<Nullable<double>>(Nullable<double> b) { return Expr<Nullable<double>>(b); }
      
      

    public:
    static Expr<Nullable<double>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<double>>(gcnew TypedExpression<Nullable<double>>(value));
      }

      static Expr<Nullable<double>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<double>>(gcnew ConvertExpression<Nullable<double>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<Nullable<double>> operator+(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<Nullable<double>>(gcnew BinaryExpression<Nullable<double>,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<Nullable<double>> operator*(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<Nullable<double>>(gcnew BinaryExpression<Nullable<double>,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<Nullable<double>> operator/(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<Nullable<double>>(gcnew BinaryExpression<Nullable<double>,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<Nullable<double>> operator-(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<Nullable<double>>(gcnew BinaryExpression<Nullable<double>,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<double>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<double>> left, Expr<Nullable<double>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<double>,Nullable<double>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<float>' expresion. Supports standard math and comparison operators.
    /// </summary>
    template<> public ref class Expr<Nullable<float>> : ExpressionWrapper<Nullable<float>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<float>::typeid; } }
    
		public:
			Expr<Nullable<float>>() { }
      Expr<Nullable<float>>(Nullable<float> val) { _value = gcnew Literal<Nullable<float>>(val); }
      Expr<Nullable<float>>(Expression<Nullable<float>>^ value) { _value = value; }
			Expr<Nullable<float>>(Expr<Nullable<float>>% b)	{ _value = b._value; }
			operator Expression<Nullable<float>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<float>>(Expression<Nullable<float>>^ value)  { return Expr<Nullable<float>>(value); }
			static operator Expr<Nullable<float>>(Nullable<float> b) { return Expr<Nullable<float>>(b); }
      
      

    public:
    static Expr<Nullable<float>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<float>>(gcnew TypedExpression<Nullable<float>>(value));
      }

      static Expr<Nullable<float>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<float>>(gcnew ConvertExpression<Nullable<float>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<Nullable<float>> operator+(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<Nullable<float>>(gcnew BinaryExpression<Nullable<float>,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<Nullable<float>> operator*(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<Nullable<float>>(gcnew BinaryExpression<Nullable<float>,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<Nullable<float>> operator/(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<Nullable<float>>(gcnew BinaryExpression<Nullable<float>,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<Nullable<float>> operator-(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<Nullable<float>>(gcnew BinaryExpression<Nullable<float>,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<float>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<float>> left, Expr<Nullable<float>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<float>,Nullable<float>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<System::Decimal>' expresion. Supports standard math and comparison operators.
    /// </summary>
    template<> public ref class Expr<Nullable<System::Decimal>> : ExpressionWrapper<Nullable<System::Decimal>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<System::Decimal>::typeid; } }
    
		public:
			Expr<Nullable<System::Decimal>>() { }
      Expr<Nullable<System::Decimal>>(Nullable<System::Decimal> val) { _value = gcnew Literal<Nullable<System::Decimal>>(val); }
      Expr<Nullable<System::Decimal>>(Expression<Nullable<System::Decimal>>^ value) { _value = value; }
			Expr<Nullable<System::Decimal>>(Expr<Nullable<System::Decimal>>% b)	{ _value = b._value; }
			operator Expression<Nullable<System::Decimal>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<System::Decimal>>(Expression<Nullable<System::Decimal>>^ value)  { return Expr<Nullable<System::Decimal>>(value); }
			static operator Expr<Nullable<System::Decimal>>(Nullable<System::Decimal> b) { return Expr<Nullable<System::Decimal>>(b); }
      
      

    public:
    static Expr<Nullable<System::Decimal>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<System::Decimal>>(gcnew TypedExpression<Nullable<System::Decimal>>(value));
      }

      static Expr<Nullable<System::Decimal>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<System::Decimal>>(gcnew ConvertExpression<Nullable<System::Decimal>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<Nullable<System::Decimal>> operator+(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<Nullable<System::Decimal>>(gcnew BinaryExpression<Nullable<System::Decimal>,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<Nullable<System::Decimal>> operator*(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<Nullable<System::Decimal>>(gcnew BinaryExpression<Nullable<System::Decimal>,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<Nullable<System::Decimal>> operator/(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<Nullable<System::Decimal>>(gcnew BinaryExpression<Nullable<System::Decimal>,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<Nullable<System::Decimal>> operator-(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<Nullable<System::Decimal>>(gcnew BinaryExpression<Nullable<System::Decimal>,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<System::Decimal>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<System::Decimal>> left, Expr<Nullable<System::Decimal>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<System::Decimal>,Nullable<System::Decimal>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<long long int>' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<Nullable<long long int>> : ExpressionWrapper<Nullable<long long int>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<long long int>::typeid; } }
    
		public:
			Expr<Nullable<long long int>>() { }
      Expr<Nullable<long long int>>(Nullable<long long int> val) { _value = gcnew Literal<Nullable<long long int>>(val); }
      Expr<Nullable<long long int>>(Expression<Nullable<long long int>>^ value) { _value = value; }
			Expr<Nullable<long long int>>(Expr<Nullable<long long int>>% b)	{ _value = b._value; }
			operator Expression<Nullable<long long int>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<long long int>>(Expression<Nullable<long long int>>^ value)  { return Expr<Nullable<long long int>>(value); }
			static operator Expr<Nullable<long long int>>(Nullable<long long int> b) { return Expr<Nullable<long long int>>(b); }
      
      

    public:
    static Expr<Nullable<long long int>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<long long int>>(gcnew TypedExpression<Nullable<long long int>>(value));
      }

      static Expr<Nullable<long long int>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<long long int>>(gcnew ConvertExpression<Nullable<long long int>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<Nullable<long long int>> operator+(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<Nullable<long long int>>(gcnew BinaryExpression<Nullable<long long int>,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<Nullable<long long int>> operator*(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<Nullable<long long int>>(gcnew BinaryExpression<Nullable<long long int>,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<Nullable<long long int>> operator/(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<Nullable<long long int>>(gcnew BinaryExpression<Nullable<long long int>,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<Nullable<long long int>> operator-(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<Nullable<long long int>>(gcnew BinaryExpression<Nullable<long long int>,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<long long int>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<long long int>> left, Expr<Nullable<long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<long long int>,Nullable<long long int>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<unsigned long long int>' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<Nullable<unsigned long long int>> : ExpressionWrapper<Nullable<unsigned long long int>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<unsigned long long int>::typeid; } }
    
		public:
			Expr<Nullable<unsigned long long int>>() { }
      Expr<Nullable<unsigned long long int>>(Nullable<unsigned long long int> val) { _value = gcnew Literal<Nullable<unsigned long long int>>(val); }
      Expr<Nullable<unsigned long long int>>(Expression<Nullable<unsigned long long int>>^ value) { _value = value; }
			Expr<Nullable<unsigned long long int>>(Expr<Nullable<unsigned long long int>>% b)	{ _value = b._value; }
			operator Expression<Nullable<unsigned long long int>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<unsigned long long int>>(Expression<Nullable<unsigned long long int>>^ value)  { return Expr<Nullable<unsigned long long int>>(value); }
			static operator Expr<Nullable<unsigned long long int>>(Nullable<unsigned long long int> b) { return Expr<Nullable<unsigned long long int>>(b); }
      
      

    public:
    static Expr<Nullable<unsigned long long int>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<unsigned long long int>>(gcnew TypedExpression<Nullable<unsigned long long int>>(value));
      }

      static Expr<Nullable<unsigned long long int>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<unsigned long long int>>(gcnew ConvertExpression<Nullable<unsigned long long int>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<Nullable<unsigned long long int>> operator+(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<Nullable<unsigned long long int>>(gcnew BinaryExpression<Nullable<unsigned long long int>,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<Nullable<unsigned long long int>> operator*(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<Nullable<unsigned long long int>>(gcnew BinaryExpression<Nullable<unsigned long long int>,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<Nullable<unsigned long long int>> operator/(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<Nullable<unsigned long long int>>(gcnew BinaryExpression<Nullable<unsigned long long int>,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<Nullable<unsigned long long int>> operator-(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<Nullable<unsigned long long int>>(gcnew BinaryExpression<Nullable<unsigned long long int>,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<unsigned long long int>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<unsigned long long int>> left, Expr<Nullable<unsigned long long int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned long long int>,Nullable<unsigned long long int>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<int>' expresion. Supports standard math and comparison operators (including modulo and shifts).
    /// </summary>
    template<> public ref class Expr<Nullable<int>> : ExpressionWrapper<Nullable<int>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<int>::typeid; } }
    
		public:
			Expr<Nullable<int>>() { }
      Expr<Nullable<int>>(Nullable<int> val) { _value = gcnew Literal<Nullable<int>>(val); }
      Expr<Nullable<int>>(Expression<Nullable<int>>^ value) { _value = value; }
			Expr<Nullable<int>>(Expr<Nullable<int>>% b)	{ _value = b._value; }
			operator Expression<Nullable<int>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<int>>(Expression<Nullable<int>>^ value)  { return Expr<Nullable<int>>(value); }
			static operator Expr<Nullable<int>>(Nullable<int> b) { return Expr<Nullable<int>>(b); }
      
      

    public:
    static Expr<Nullable<int>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<int>>(gcnew TypedExpression<Nullable<int>>(value));
      }

      static Expr<Nullable<int>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<int>>(gcnew ConvertExpression<Nullable<int>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<Nullable<int>> operator+(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<Nullable<int>> operator*(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<Nullable<int>> operator/(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<Nullable<int>> operator-(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

      /// <summary>
      /// Shift left operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<Nullable<int>> operator<<(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::LShift));
      }

      /// <summary>
      /// Shift right operator for tuple of Expr<Nullable<int>> types.
      /// </summary>
      static Expr<Nullable<int>> operator>>(Expr<Nullable<int>> left, Expr<Nullable<int>> right)
      {
        return Expr<Nullable<int>>(gcnew BinaryExpression<Nullable<int>,Nullable<int>,Nullable<int>>
          (left, right, System::Expressions::ExpressionType::RShift));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<unsigned int>' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<Nullable<unsigned int>> : ExpressionWrapper<Nullable<unsigned int>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<unsigned int>::typeid; } }
    
		public:
			Expr<Nullable<unsigned int>>() { }
      Expr<Nullable<unsigned int>>(Nullable<unsigned int> val) { _value = gcnew Literal<Nullable<unsigned int>>(val); }
      Expr<Nullable<unsigned int>>(Expression<Nullable<unsigned int>>^ value) { _value = value; }
			Expr<Nullable<unsigned int>>(Expr<Nullable<unsigned int>>% b)	{ _value = b._value; }
			operator Expression<Nullable<unsigned int>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<unsigned int>>(Expression<Nullable<unsigned int>>^ value)  { return Expr<Nullable<unsigned int>>(value); }
			static operator Expr<Nullable<unsigned int>>(Nullable<unsigned int> b) { return Expr<Nullable<unsigned int>>(b); }
      
      

    public:
    static Expr<Nullable<unsigned int>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<unsigned int>>(gcnew TypedExpression<Nullable<unsigned int>>(value));
      }

      static Expr<Nullable<unsigned int>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<unsigned int>>(gcnew ConvertExpression<Nullable<unsigned int>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<Nullable<unsigned int>> operator+(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<Nullable<unsigned int>>(gcnew BinaryExpression<Nullable<unsigned int>,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<Nullable<unsigned int>> operator*(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<Nullable<unsigned int>>(gcnew BinaryExpression<Nullable<unsigned int>,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<Nullable<unsigned int>> operator/(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<Nullable<unsigned int>>(gcnew BinaryExpression<Nullable<unsigned int>,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<Nullable<unsigned int>> operator-(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<Nullable<unsigned int>>(gcnew BinaryExpression<Nullable<unsigned int>,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<unsigned int>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<unsigned int>> left, Expr<Nullable<unsigned int>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned int>,Nullable<unsigned int>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<short>' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<Nullable<short>> : ExpressionWrapper<Nullable<short>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<short>::typeid; } }
    
		public:
			Expr<Nullable<short>>() { }
      Expr<Nullable<short>>(Nullable<short> val) { _value = gcnew Literal<Nullable<short>>(val); }
      Expr<Nullable<short>>(Expression<Nullable<short>>^ value) { _value = value; }
			Expr<Nullable<short>>(Expr<Nullable<short>>% b)	{ _value = b._value; }
			operator Expression<Nullable<short>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<short>>(Expression<Nullable<short>>^ value)  { return Expr<Nullable<short>>(value); }
			static operator Expr<Nullable<short>>(Nullable<short> b) { return Expr<Nullable<short>>(b); }
      
      

    public:
    static Expr<Nullable<short>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<short>>(gcnew TypedExpression<Nullable<short>>(value));
      }

      static Expr<Nullable<short>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<short>>(gcnew ConvertExpression<Nullable<short>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<Nullable<short>> operator+(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<Nullable<short>>(gcnew BinaryExpression<Nullable<short>,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<Nullable<short>> operator*(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<Nullable<short>>(gcnew BinaryExpression<Nullable<short>,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<Nullable<short>> operator/(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<Nullable<short>>(gcnew BinaryExpression<Nullable<short>,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<Nullable<short>> operator-(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<Nullable<short>>(gcnew BinaryExpression<Nullable<short>,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<short>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<short>> left, Expr<Nullable<short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<short>,Nullable<short>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<unsigned short>' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<Nullable<unsigned short>> : ExpressionWrapper<Nullable<unsigned short>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<unsigned short>::typeid; } }
    
		public:
			Expr<Nullable<unsigned short>>() { }
      Expr<Nullable<unsigned short>>(Nullable<unsigned short> val) { _value = gcnew Literal<Nullable<unsigned short>>(val); }
      Expr<Nullable<unsigned short>>(Expression<Nullable<unsigned short>>^ value) { _value = value; }
			Expr<Nullable<unsigned short>>(Expr<Nullable<unsigned short>>% b)	{ _value = b._value; }
			operator Expression<Nullable<unsigned short>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<unsigned short>>(Expression<Nullable<unsigned short>>^ value)  { return Expr<Nullable<unsigned short>>(value); }
			static operator Expr<Nullable<unsigned short>>(Nullable<unsigned short> b) { return Expr<Nullable<unsigned short>>(b); }
      
      

    public:
    static Expr<Nullable<unsigned short>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<unsigned short>>(gcnew TypedExpression<Nullable<unsigned short>>(value));
      }

      static Expr<Nullable<unsigned short>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<unsigned short>>(gcnew ConvertExpression<Nullable<unsigned short>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<Nullable<unsigned short>> operator+(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<Nullable<unsigned short>>(gcnew BinaryExpression<Nullable<unsigned short>,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<Nullable<unsigned short>> operator*(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<Nullable<unsigned short>>(gcnew BinaryExpression<Nullable<unsigned short>,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<Nullable<unsigned short>> operator/(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<Nullable<unsigned short>>(gcnew BinaryExpression<Nullable<unsigned short>,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<Nullable<unsigned short>> operator-(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<Nullable<unsigned short>>(gcnew BinaryExpression<Nullable<unsigned short>,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<unsigned short>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<unsigned short>> left, Expr<Nullable<unsigned short>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned short>,Nullable<unsigned short>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<unsigned char>' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<Nullable<unsigned char>> : ExpressionWrapper<Nullable<unsigned char>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<unsigned char>::typeid; } }
    
		public:
			Expr<Nullable<unsigned char>>() { }
      Expr<Nullable<unsigned char>>(Nullable<unsigned char> val) { _value = gcnew Literal<Nullable<unsigned char>>(val); }
      Expr<Nullable<unsigned char>>(Expression<Nullable<unsigned char>>^ value) { _value = value; }
			Expr<Nullable<unsigned char>>(Expr<Nullable<unsigned char>>% b)	{ _value = b._value; }
			operator Expression<Nullable<unsigned char>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<unsigned char>>(Expression<Nullable<unsigned char>>^ value)  { return Expr<Nullable<unsigned char>>(value); }
			static operator Expr<Nullable<unsigned char>>(Nullable<unsigned char> b) { return Expr<Nullable<unsigned char>>(b); }
      
      

    public:
    static Expr<Nullable<unsigned char>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<unsigned char>>(gcnew TypedExpression<Nullable<unsigned char>>(value));
      }

      static Expr<Nullable<unsigned char>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<unsigned char>>(gcnew ConvertExpression<Nullable<unsigned char>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<Nullable<unsigned char>> operator+(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<Nullable<unsigned char>>(gcnew BinaryExpression<Nullable<unsigned char>,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<Nullable<unsigned char>> operator*(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<Nullable<unsigned char>>(gcnew BinaryExpression<Nullable<unsigned char>,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<Nullable<unsigned char>> operator/(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<Nullable<unsigned char>>(gcnew BinaryExpression<Nullable<unsigned char>,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<Nullable<unsigned char>> operator-(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<Nullable<unsigned char>>(gcnew BinaryExpression<Nullable<unsigned char>,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<unsigned char>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<unsigned char>> left, Expr<Nullable<unsigned char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<unsigned char>,Nullable<unsigned char>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<signed char>' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<Nullable<signed char>> : ExpressionWrapper<Nullable<signed char>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<signed char>::typeid; } }
    
		public:
			Expr<Nullable<signed char>>() { }
      Expr<Nullable<signed char>>(Nullable<signed char> val) { _value = gcnew Literal<Nullable<signed char>>(val); }
      Expr<Nullable<signed char>>(Expression<Nullable<signed char>>^ value) { _value = value; }
			Expr<Nullable<signed char>>(Expr<Nullable<signed char>>% b)	{ _value = b._value; }
			operator Expression<Nullable<signed char>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<signed char>>(Expression<Nullable<signed char>>^ value)  { return Expr<Nullable<signed char>>(value); }
			static operator Expr<Nullable<signed char>>(Nullable<signed char> b) { return Expr<Nullable<signed char>>(b); }
      
      

    public:
    static Expr<Nullable<signed char>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<signed char>>(gcnew TypedExpression<Nullable<signed char>>(value));
      }

      static Expr<Nullable<signed char>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<signed char>>(gcnew ConvertExpression<Nullable<signed char>>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<Nullable<signed char>> operator+(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<Nullable<signed char>>(gcnew BinaryExpression<Nullable<signed char>,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<Nullable<signed char>> operator*(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<Nullable<signed char>>(gcnew BinaryExpression<Nullable<signed char>,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<Nullable<signed char>> operator/(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<Nullable<signed char>>(gcnew BinaryExpression<Nullable<signed char>,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<Nullable<signed char>> operator-(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<Nullable<signed char>>(gcnew BinaryExpression<Nullable<signed char>,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<bool> operator==(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<bool> operator<(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<bool> operator>(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<Nullable<signed char>> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<Nullable<signed char>> left, Expr<Nullable<signed char>> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,Nullable<signed char>,Nullable<signed char>>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'double' expresion. Supports standard math and comparison operators.
    /// </summary>
    template<> public ref class Expr<double> : ExpressionWrapper<double>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return double::typeid; } }
    
		public:
			Expr<double>() { }
      Expr<double>(double val) { _value = gcnew Literal<double>(val); }
      Expr<double>(Expression<double>^ value) { _value = value; }
			Expr<double>(Expr<double>% b)	{ _value = b._value; }
			operator Expression<double>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<double>(Expression<double>^ value)  { return Expr<double>(value); }
			static operator Expr<double>(double b) { return Expr<double>(b); }
      
      

    public:
    static Expr<double> Typed(GenericExpression^ value) 
      { 
        return Expr<double>(gcnew TypedExpression<double>(value));
      }

      static Expr<double> Convert(GenericExpression^ value) 
      { 
        return Expr<double>(gcnew ConvertExpression<double>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<double> operator+(Expr<double> left, Expr<double> right)
      {
        return Expr<double>(gcnew BinaryExpression<double,double,double>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<double> operator*(Expr<double> left, Expr<double> right)
      {
        return Expr<double>(gcnew BinaryExpression<double,double,double>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<double> operator/(Expr<double> left, Expr<double> right)
      {
        return Expr<double>(gcnew BinaryExpression<double,double,double>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<double> operator-(Expr<double> left, Expr<double> right)
      {
        return Expr<double>(gcnew BinaryExpression<double,double,double>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<bool> operator==(Expr<double> left, Expr<double> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,double,double>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<double> left, Expr<double> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,double,double>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<bool> operator<(Expr<double> left, Expr<double> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,double,double>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<bool> operator>(Expr<double> left, Expr<double> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,double,double>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<double> left, Expr<double> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,double,double>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<double> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<double> left, Expr<double> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,double,double>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'float' expresion. Supports standard math and comparison operators.
    /// </summary>
    template<> public ref class Expr<float> : ExpressionWrapper<float>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return float::typeid; } }
    
		public:
			Expr<float>() { }
      Expr<float>(float val) { _value = gcnew Literal<float>(val); }
      Expr<float>(Expression<float>^ value) { _value = value; }
			Expr<float>(Expr<float>% b)	{ _value = b._value; }
			operator Expression<float>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<float>(Expression<float>^ value)  { return Expr<float>(value); }
			static operator Expr<float>(float b) { return Expr<float>(b); }
      
      
      operator Expr<double>() { return Expr<double>::Convert(_value); }

    public:
    static Expr<float> Typed(GenericExpression^ value) 
      { 
        return Expr<float>(gcnew TypedExpression<float>(value));
      }

      static Expr<float> Convert(GenericExpression^ value) 
      { 
        return Expr<float>(gcnew ConvertExpression<float>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<float> operator+(Expr<float> left, Expr<float> right)
      {
        return Expr<float>(gcnew BinaryExpression<float,float,float>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<float> operator*(Expr<float> left, Expr<float> right)
      {
        return Expr<float>(gcnew BinaryExpression<float,float,float>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<float> operator/(Expr<float> left, Expr<float> right)
      {
        return Expr<float>(gcnew BinaryExpression<float,float,float>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<float> operator-(Expr<float> left, Expr<float> right)
      {
        return Expr<float>(gcnew BinaryExpression<float,float,float>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<bool> operator==(Expr<float> left, Expr<float> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,float,float>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<float> left, Expr<float> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,float,float>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<bool> operator<(Expr<float> left, Expr<float> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,float,float>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<bool> operator>(Expr<float> left, Expr<float> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,float,float>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<float> left, Expr<float> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,float,float>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<float> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<float> left, Expr<float> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,float,float>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'System::Decimal' expresion. Supports standard math and comparison operators.
    /// </summary>
    template<> public ref class Expr<System::Decimal> : ExpressionWrapper<System::Decimal>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return System::Decimal::typeid; } }
    
		public:
			Expr<System::Decimal>() { }
      Expr<System::Decimal>(System::Decimal val) { _value = gcnew Literal<System::Decimal>(val); }
      Expr<System::Decimal>(Expression<System::Decimal>^ value) { _value = value; }
			Expr<System::Decimal>(Expr<System::Decimal>% b)	{ _value = b._value; }
			operator Expression<System::Decimal>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<System::Decimal>(Expression<System::Decimal>^ value)  { return Expr<System::Decimal>(value); }
			static operator Expr<System::Decimal>(System::Decimal b) { return Expr<System::Decimal>(b); }
      
      

    public:
    static Expr<System::Decimal> Typed(GenericExpression^ value) 
      { 
        return Expr<System::Decimal>(gcnew TypedExpression<System::Decimal>(value));
      }

      static Expr<System::Decimal> Convert(GenericExpression^ value) 
      { 
        return Expr<System::Decimal>(gcnew ConvertExpression<System::Decimal>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<System::Decimal> operator+(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<System::Decimal>(gcnew BinaryExpression<System::Decimal,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<System::Decimal> operator*(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<System::Decimal>(gcnew BinaryExpression<System::Decimal,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<System::Decimal> operator/(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<System::Decimal>(gcnew BinaryExpression<System::Decimal,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<System::Decimal> operator-(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<System::Decimal>(gcnew BinaryExpression<System::Decimal,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<bool> operator==(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<bool> operator<(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<bool> operator>(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<System::Decimal> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<System::Decimal> left, Expr<System::Decimal> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,System::Decimal,System::Decimal>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'long long int' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<long long int> : ExpressionWrapper<long long int>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return long long int::typeid; } }
    
		public:
			Expr<long long int>() { }
      Expr<long long int>(long long int val) { _value = gcnew Literal<long long int>(val); }
      Expr<long long int>(Expression<long long int>^ value) { _value = value; }
			Expr<long long int>(Expr<long long int>% b)	{ _value = b._value; }
			operator Expression<long long int>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<long long int>(Expression<long long int>^ value)  { return Expr<long long int>(value); }
			static operator Expr<long long int>(long long int b) { return Expr<long long int>(b); }
      
      

    public:
    static Expr<long long int> Typed(GenericExpression^ value) 
      { 
        return Expr<long long int>(gcnew TypedExpression<long long int>(value));
      }

      static Expr<long long int> Convert(GenericExpression^ value) 
      { 
        return Expr<long long int>(gcnew ConvertExpression<long long int>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<long long int> operator+(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<long long int>(gcnew BinaryExpression<long long int,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<long long int> operator*(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<long long int>(gcnew BinaryExpression<long long int,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<long long int> operator/(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<long long int>(gcnew BinaryExpression<long long int,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<long long int> operator-(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<long long int>(gcnew BinaryExpression<long long int,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<bool> operator==(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<bool> operator<(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<bool> operator>(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<long long int> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<long long int> left, Expr<long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,long long int,long long int>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'unsigned long long int' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<unsigned long long int> : ExpressionWrapper<unsigned long long int>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return unsigned long long int::typeid; } }
    
		public:
			Expr<unsigned long long int>() { }
      Expr<unsigned long long int>(unsigned long long int val) { _value = gcnew Literal<unsigned long long int>(val); }
      Expr<unsigned long long int>(Expression<unsigned long long int>^ value) { _value = value; }
			Expr<unsigned long long int>(Expr<unsigned long long int>% b)	{ _value = b._value; }
			operator Expression<unsigned long long int>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<unsigned long long int>(Expression<unsigned long long int>^ value)  { return Expr<unsigned long long int>(value); }
			static operator Expr<unsigned long long int>(unsigned long long int b) { return Expr<unsigned long long int>(b); }
      
      

    public:
    static Expr<unsigned long long int> Typed(GenericExpression^ value) 
      { 
        return Expr<unsigned long long int>(gcnew TypedExpression<unsigned long long int>(value));
      }

      static Expr<unsigned long long int> Convert(GenericExpression^ value) 
      { 
        return Expr<unsigned long long int>(gcnew ConvertExpression<unsigned long long int>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<unsigned long long int> operator+(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<unsigned long long int>(gcnew BinaryExpression<unsigned long long int,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<unsigned long long int> operator*(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<unsigned long long int>(gcnew BinaryExpression<unsigned long long int,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<unsigned long long int> operator/(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<unsigned long long int>(gcnew BinaryExpression<unsigned long long int,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<unsigned long long int> operator-(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<unsigned long long int>(gcnew BinaryExpression<unsigned long long int,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<bool> operator==(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<bool> operator<(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<bool> operator>(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<unsigned long long int> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<unsigned long long int> left, Expr<unsigned long long int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned long long int,unsigned long long int>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'int' expresion. Supports standard math and comparison operators (including modulo and shifts).
    /// </summary>
    template<> public ref class Expr<int> : ExpressionWrapper<int>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return int::typeid; } }
    
		public:
			Expr<int>() { }
      Expr<int>(int val) { _value = gcnew Literal<int>(val); }
      Expr<int>(Expression<int>^ value) { _value = value; }
			Expr<int>(Expr<int>% b)	{ _value = b._value; }
			operator Expression<int>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<int>(Expression<int>^ value)  { return Expr<int>(value); }
			static operator Expr<int>(int b) { return Expr<int>(b); }
      
      
      operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
      operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }

    public:
    static Expr<int> Typed(GenericExpression^ value) 
      { 
        return Expr<int>(gcnew TypedExpression<int>(value));
      }

      static Expr<int> Convert(GenericExpression^ value) 
      { 
        return Expr<int>(gcnew ConvertExpression<int>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<int> operator+(Expr<int> left, Expr<int> right)
      {
        return Expr<int>(gcnew BinaryExpression<int,int,int>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<int> operator*(Expr<int> left, Expr<int> right)
      {
        return Expr<int>(gcnew BinaryExpression<int,int,int>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<int> operator/(Expr<int> left, Expr<int> right)
      {
        return Expr<int>(gcnew BinaryExpression<int,int,int>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<int> operator-(Expr<int> left, Expr<int> right)
      {
        return Expr<int>(gcnew BinaryExpression<int,int,int>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<bool> operator==(Expr<int> left, Expr<int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,int,int>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<int> left, Expr<int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,int,int>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<bool> operator<(Expr<int> left, Expr<int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,int,int>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<bool> operator>(Expr<int> left, Expr<int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,int,int>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<int> left, Expr<int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,int,int>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<int> left, Expr<int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,int,int>
          (left, right, System::Expressions::ExpressionType::GE));
      }

      /// <summary>
      /// Shift left operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<int> operator<<(Expr<int> left, Expr<int> right)
      {
        return Expr<int>(gcnew BinaryExpression<int,int,int>
          (left, right, System::Expressions::ExpressionType::LShift));
      }

      /// <summary>
      /// Shift right operator for tuple of Expr<int> types.
      /// </summary>
      static Expr<int> operator>>(Expr<int> left, Expr<int> right)
      {
        return Expr<int>(gcnew BinaryExpression<int,int,int>
          (left, right, System::Expressions::ExpressionType::RShift));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'unsigned int' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<unsigned int> : ExpressionWrapper<unsigned int>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return unsigned int::typeid; } }
    
		public:
			Expr<unsigned int>() { }
      Expr<unsigned int>(unsigned int val) { _value = gcnew Literal<unsigned int>(val); }
      Expr<unsigned int>(Expression<unsigned int>^ value) { _value = value; }
			Expr<unsigned int>(Expr<unsigned int>% b)	{ _value = b._value; }
			operator Expression<unsigned int>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<unsigned int>(Expression<unsigned int>^ value)  { return Expr<unsigned int>(value); }
			static operator Expr<unsigned int>(unsigned int b) { return Expr<unsigned int>(b); }
      
      
      operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
      operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }

    public:
    static Expr<unsigned int> Typed(GenericExpression^ value) 
      { 
        return Expr<unsigned int>(gcnew TypedExpression<unsigned int>(value));
      }

      static Expr<unsigned int> Convert(GenericExpression^ value) 
      { 
        return Expr<unsigned int>(gcnew ConvertExpression<unsigned int>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<unsigned int> operator+(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<unsigned int>(gcnew BinaryExpression<unsigned int,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<unsigned int> operator*(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<unsigned int>(gcnew BinaryExpression<unsigned int,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<unsigned int> operator/(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<unsigned int>(gcnew BinaryExpression<unsigned int,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<unsigned int> operator-(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<unsigned int>(gcnew BinaryExpression<unsigned int,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<bool> operator==(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<bool> operator<(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<bool> operator>(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<unsigned int> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<unsigned int> left, Expr<unsigned int> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned int,unsigned int>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'short' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<short> : ExpressionWrapper<short>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return short::typeid; } }
    
		public:
			Expr<short>() { }
      Expr<short>(short val) { _value = gcnew Literal<short>(val); }
      Expr<short>(Expression<short>^ value) { _value = value; }
			Expr<short>(Expr<short>% b)	{ _value = b._value; }
			operator Expression<short>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<short>(Expression<short>^ value)  { return Expr<short>(value); }
			static operator Expr<short>(short b) { return Expr<short>(b); }
      
      
      operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
      operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
      operator Expr<int>() { return Expr<int>::Convert(_value); }
      operator Expr<unsigned int>() { return Expr<unsigned int>::Convert(_value); }

    public:
    static Expr<short> Typed(GenericExpression^ value) 
      { 
        return Expr<short>(gcnew TypedExpression<short>(value));
      }

      static Expr<short> Convert(GenericExpression^ value) 
      { 
        return Expr<short>(gcnew ConvertExpression<short>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<short> operator+(Expr<short> left, Expr<short> right)
      {
        return Expr<short>(gcnew BinaryExpression<short,short,short>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<short> operator*(Expr<short> left, Expr<short> right)
      {
        return Expr<short>(gcnew BinaryExpression<short,short,short>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<short> operator/(Expr<short> left, Expr<short> right)
      {
        return Expr<short>(gcnew BinaryExpression<short,short,short>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<short> operator-(Expr<short> left, Expr<short> right)
      {
        return Expr<short>(gcnew BinaryExpression<short,short,short>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<bool> operator==(Expr<short> left, Expr<short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,short,short>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<short> left, Expr<short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,short,short>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<bool> operator<(Expr<short> left, Expr<short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,short,short>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<bool> operator>(Expr<short> left, Expr<short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,short,short>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<short> left, Expr<short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,short,short>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<short> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<short> left, Expr<short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,short,short>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'unsigned short' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<unsigned short> : ExpressionWrapper<unsigned short>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return unsigned short::typeid; } }
    
		public:
			Expr<unsigned short>() { }
      Expr<unsigned short>(unsigned short val) { _value = gcnew Literal<unsigned short>(val); }
      Expr<unsigned short>(Expression<unsigned short>^ value) { _value = value; }
			Expr<unsigned short>(Expr<unsigned short>% b)	{ _value = b._value; }
			operator Expression<unsigned short>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<unsigned short>(Expression<unsigned short>^ value)  { return Expr<unsigned short>(value); }
			static operator Expr<unsigned short>(unsigned short b) { return Expr<unsigned short>(b); }
      
      
      operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
      operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
      operator Expr<int>() { return Expr<int>::Convert(_value); }
      operator Expr<unsigned int>() { return Expr<unsigned int>::Convert(_value); }

    public:
    static Expr<unsigned short> Typed(GenericExpression^ value) 
      { 
        return Expr<unsigned short>(gcnew TypedExpression<unsigned short>(value));
      }

      static Expr<unsigned short> Convert(GenericExpression^ value) 
      { 
        return Expr<unsigned short>(gcnew ConvertExpression<unsigned short>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<unsigned short> operator+(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<unsigned short>(gcnew BinaryExpression<unsigned short,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<unsigned short> operator*(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<unsigned short>(gcnew BinaryExpression<unsigned short,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<unsigned short> operator/(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<unsigned short>(gcnew BinaryExpression<unsigned short,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<unsigned short> operator-(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<unsigned short>(gcnew BinaryExpression<unsigned short,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<bool> operator==(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<bool> operator<(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<bool> operator>(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<unsigned short> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<unsigned short> left, Expr<unsigned short> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned short,unsigned short>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'unsigned char' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<unsigned char> : ExpressionWrapper<unsigned char>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return unsigned char::typeid; } }
    
		public:
			Expr<unsigned char>() { }
      Expr<unsigned char>(unsigned char val) { _value = gcnew Literal<unsigned char>(val); }
      Expr<unsigned char>(Expression<unsigned char>^ value) { _value = value; }
			Expr<unsigned char>(Expr<unsigned char>% b)	{ _value = b._value; }
			operator Expression<unsigned char>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<unsigned char>(Expression<unsigned char>^ value)  { return Expr<unsigned char>(value); }
			static operator Expr<unsigned char>(unsigned char b) { return Expr<unsigned char>(b); }
      
      
      operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
      operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
      operator Expr<int>() { return Expr<int>::Convert(_value); }
      operator Expr<unsigned int>() { return Expr<unsigned int>::Convert(_value); }
      operator Expr<short>() { return Expr<short>::Convert(_value); }
      operator Expr<unsigned short>() { return Expr<unsigned short>::Convert(_value); }

    public:
    static Expr<unsigned char> Typed(GenericExpression^ value) 
      { 
        return Expr<unsigned char>(gcnew TypedExpression<unsigned char>(value));
      }

      static Expr<unsigned char> Convert(GenericExpression^ value) 
      { 
        return Expr<unsigned char>(gcnew ConvertExpression<unsigned char>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<unsigned char> operator+(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<unsigned char>(gcnew BinaryExpression<unsigned char,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<unsigned char> operator*(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<unsigned char>(gcnew BinaryExpression<unsigned char,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<unsigned char> operator/(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<unsigned char>(gcnew BinaryExpression<unsigned char,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<unsigned char> operator-(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<unsigned char>(gcnew BinaryExpression<unsigned char,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<bool> operator==(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<bool> operator<(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<bool> operator>(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<unsigned char> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<unsigned char> left, Expr<unsigned char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,unsigned char,unsigned char>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'signed char' expresion. Supports standard math and comparison operators (including modulo).
    /// </summary>
    template<> public ref class Expr<signed char> : ExpressionWrapper<signed char>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return signed char::typeid; } }
    
		public:
			Expr<signed char>() { }
      Expr<signed char>(signed char val) { _value = gcnew Literal<signed char>(val); }
      Expr<signed char>(Expression<signed char>^ value) { _value = value; }
			Expr<signed char>(Expr<signed char>% b)	{ _value = b._value; }
			operator Expression<signed char>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<signed char>(Expression<signed char>^ value)  { return Expr<signed char>(value); }
			static operator Expr<signed char>(signed char b) { return Expr<signed char>(b); }
      
      
      operator Expr<long long int>() { return Expr<long long int>::Convert(_value); }
      operator Expr<unsigned long long int>() { return Expr<unsigned long long int>::Convert(_value); }
      operator Expr<int>() { return Expr<int>::Convert(_value); }
      operator Expr<unsigned int>() { return Expr<unsigned int>::Convert(_value); }
      operator Expr<short>() { return Expr<short>::Convert(_value); }
      operator Expr<unsigned short>() { return Expr<unsigned short>::Convert(_value); }

    public:
    static Expr<signed char> Typed(GenericExpression^ value) 
      { 
        return Expr<signed char>(gcnew TypedExpression<signed char>(value));
      }

      static Expr<signed char> Convert(GenericExpression^ value) 
      { 
        return Expr<signed char>(gcnew ConvertExpression<signed char>(value));
      }

    public:
      
      /// <summary>
      /// Addition operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<signed char> operator+(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<signed char>(gcnew BinaryExpression<signed char,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// Multiplication operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<signed char> operator*(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<signed char>(gcnew BinaryExpression<signed char,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::Multiply));
      }

      /// <summary>
      /// Division operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<signed char> operator/(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<signed char>(gcnew BinaryExpression<signed char,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::Divide));
      }

      /// <summary>
      /// Subtraction operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<signed char> operator-(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<signed char>(gcnew BinaryExpression<signed char,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::Subtract));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<bool> operator==(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Less than operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<bool> operator<(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::LT));
      }

      /// <summary>
      /// Greather than operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<bool> operator>(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::GT));
      }

      /// <summary>
      /// Less or equals operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<bool> operator<=(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::LE));
      }

      /// <summary>
      /// Greather or equals than operator for tuple of Expr<signed char> types.
      /// </summary>
      static Expr<bool> operator>=(Expr<signed char> left, Expr<signed char> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,signed char,signed char>
          (left, right, System::Expressions::ExpressionType::GE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'wchar_t' expresion. Supports comparison operators.
    /// </summary>
    template<> public ref class Expr<wchar_t> : ExpressionWrapper<wchar_t>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return wchar_t::typeid; } }
    
		public:
			Expr<wchar_t>() { }
      Expr<wchar_t>(wchar_t val) { _value = gcnew Literal<wchar_t>(val); }
      Expr<wchar_t>(Expression<wchar_t>^ value) { _value = value; }
			Expr<wchar_t>(Expr<wchar_t>% b)	{ _value = b._value; }
			operator Expression<wchar_t>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<wchar_t>(Expression<wchar_t>^ value)  { return Expr<wchar_t>(value); }
			static operator Expr<wchar_t>(wchar_t b) { return Expr<wchar_t>(b); }
      
      

    public:
    static Expr<wchar_t> Typed(GenericExpression^ value) 
      { 
        return Expr<wchar_t>(gcnew TypedExpression<wchar_t>(value));
      }

      static Expr<wchar_t> Convert(GenericExpression^ value) 
      { 
        return Expr<wchar_t>(gcnew ConvertExpression<wchar_t>(value));
      }

    public:
      
      /// <summary>
      /// Test values for equality.
      /// </summary>
      static Expr<bool> operator==(Expr<wchar_t> left, Expr<wchar_t> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,wchar_t,wchar_t>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Test values for inequality.
      /// </summary>
      static Expr<bool> operator!=(Expr<wchar_t> left, Expr<wchar_t> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,wchar_t,wchar_t>
          (left, right, System::Expressions::ExpressionType::NE));
      }

  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'String^' expresion. Support standard string operators and methods.
    /// </summary>
    template<> public ref class Expr<String^> : ExpressionWrapper<String^>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return String::typeid; } }
    
		public:
			Expr<String^>() { }
      Expr<String^>(String^ val) { _value = gcnew Literal<String^>(val); }
      Expr<String^>(Expression<String^>^ value) { _value = value; }
			Expr<String^>(Expr<String^>% b)	{ _value = b._value; }
			operator Expression<String^>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<String^>(Expression<String^>^ value)  { return Expr<String^>(value); }
			static operator Expr<String^>(String^ b) { return Expr<String^>(b); }
      
      

    public:
    static Expr<String^> Typed(GenericExpression^ value) 
      { 
        return Expr<String^>(gcnew TypedExpression<String^>(value));
      }

      static Expr<String^> Convert(GenericExpression^ value) 
      { 
        return Expr<String^>(gcnew ConvertExpression<String^>(value));
      }

    public:
      
      /// <summary>
      /// Operator for string concatenation.
      /// </summary>
      static Expr<String^> operator+(Expr<String^> left, Expr<String^> right)
      {
        return Expr<String^>(gcnew BinaryExpression<String^,String^,String^>
          (left, right, System::Expressions::ExpressionType::Add));
      }

      /// <summary>
      /// comparison operator for tuple of Expr<String^> types.
      /// </summary>
      static Expr<bool> operator==(Expr<String^> left, Expr<String^> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,String^,String^>
          (left, right, System::Expressions::ExpressionType::EQ));
      }

      /// <summary>
      /// Inequallity operator for tuple of Expr<String^> types.
      /// </summary>
      static Expr<bool> operator!=(Expr<String^> left, Expr<String^> right)
      {
        return Expr<bool>(gcnew BinaryExpression<bool,String^,String^>
          (left, right, System::Expressions::ExpressionType::NE));
      }

  
    public:
      
    private:
    	static MethodInfo^ __Substring_Expr_int_;
    	static property MethodInfo^ _Substring_Expr_int_ { 
        MethodInfo^ get() { if (__Substring_Expr_int_ == nullptr) 
          __Substring_Expr_int_ = (String::typeid)->GetMethod("Substring", gcnew array<Type^>{ Expr<int>::WrappedType }); return __Substring_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Retrieves a substring from this instance.
      /// </summary>
      Expr<String^> Substring(Expr<int> startIndex)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Substring_Expr_int_, this, gcnew array<GenericExpression^>{startIndex}));
      }

    private:
    	static MethodInfo^ __Substring_Expr_int__Expr_int_;
    	static property MethodInfo^ _Substring_Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__Substring_Expr_int__Expr_int_ == nullptr) 
          __Substring_Expr_int__Expr_int_ = (String::typeid)->GetMethod("Substring", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __Substring_Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Retrieves a substring from this instance.
      /// </summary>
      Expr<String^> Substring(Expr<int> startIndex, Expr<int> length)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Substring_Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{startIndex, length}));
      }

    private:
    	static MethodInfo^ __Contains_Expr_String__;
    	static property MethodInfo^ _Contains_Expr_String__ { 
        MethodInfo^ get() { if (__Contains_Expr_String__ == nullptr) 
          __Contains_Expr_String__ = (String::typeid)->GetMethod("Contains", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __Contains_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Returns a value indicating whether the specified String object occurs within this string.
      /// </summary>
      Expr<bool> Contains(Expr<String^> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_Contains_Expr_String__, this, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __StartsWith_Expr_String__;
    	static property MethodInfo^ _StartsWith_Expr_String__ { 
        MethodInfo^ get() { if (__StartsWith_Expr_String__ == nullptr) 
          __StartsWith_Expr_String__ = (String::typeid)->GetMethod("StartsWith", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __StartsWith_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Determines whether the beginning of an instance of String matches a specified string.
      /// </summary>
      Expr<bool> StartsWith(Expr<String^> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_StartsWith_Expr_String__, this, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __EndsWith_Expr_String__;
    	static property MethodInfo^ _EndsWith_Expr_String__ { 
        MethodInfo^ get() { if (__EndsWith_Expr_String__ == nullptr) 
          __EndsWith_Expr_String__ = (String::typeid)->GetMethod("EndsWith", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __EndsWith_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Determines whether the end of an instance of String matches a specified string.
      /// </summary>
      Expr<bool> EndsWith(Expr<String^> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_EndsWith_Expr_String__, this, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __IndexOf_Expr_wchar_t_;
    	static property MethodInfo^ _IndexOf_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__IndexOf_Expr_wchar_t_ == nullptr) 
          __IndexOf_Expr_wchar_t_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __IndexOf_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Reports the index of the first occurrence of a String, or one or more characters, within this string.
      /// </summary>
      Expr<int> IndexOf(Expr<wchar_t> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_IndexOf_Expr_wchar_t_, this, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __IndexOf_Expr_String__;
    	static property MethodInfo^ _IndexOf_Expr_String__ { 
        MethodInfo^ get() { if (__IndexOf_Expr_String__ == nullptr) 
          __IndexOf_Expr_String__ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __IndexOf_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Reports the index of the first occurrence of a String, or one or more characters, within this string.
      /// </summary>
      Expr<int> IndexOf(Expr<String^> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_IndexOf_Expr_String__, this, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __IndexOf_Expr_wchar_t__Expr_int_;
    	static property MethodInfo^ _IndexOf_Expr_wchar_t__Expr_int_ { 
        MethodInfo^ get() { if (__IndexOf_Expr_wchar_t__Expr_int_ == nullptr) 
          __IndexOf_Expr_wchar_t__Expr_int_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<int>::WrappedType }); return __IndexOf_Expr_wchar_t__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Reports the index of the first occurrence of a String, or one or more characters, within this string.
      /// </summary>
      Expr<int> IndexOf(Expr<wchar_t> value, Expr<int> startIndex)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_IndexOf_Expr_wchar_t__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex}));
      }

    private:
    	static MethodInfo^ __IndexOf_Expr_String___Expr_int_;
    	static property MethodInfo^ _IndexOf_Expr_String___Expr_int_ { 
        MethodInfo^ get() { if (__IndexOf_Expr_String___Expr_int_ == nullptr) 
          __IndexOf_Expr_String___Expr_int_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<int>::WrappedType }); return __IndexOf_Expr_String___Expr_int_; 
        } }
    public:
      /// <summary>
      /// Reports the index of the first occurrence of a String, or one or more characters, within this string.
      /// </summary>
      Expr<int> IndexOf(Expr<String^> value, Expr<int> startIndex)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_IndexOf_Expr_String___Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex}));
      }

    private:
    	static MethodInfo^ __IndexOf_Expr_wchar_t__Expr_int__Expr_int_;
    	static property MethodInfo^ _IndexOf_Expr_wchar_t__Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__IndexOf_Expr_wchar_t__Expr_int__Expr_int_ == nullptr) 
          __IndexOf_Expr_wchar_t__Expr_int__Expr_int_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<int>::WrappedType, Expr<int>::WrappedType }); return __IndexOf_Expr_wchar_t__Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Reports the index of the first occurrence of a String, or one or more characters, within this string.
      /// </summary>
      Expr<int> IndexOf(Expr<wchar_t> value, Expr<int> startIndex, Expr<int> count)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_IndexOf_Expr_wchar_t__Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex, count}));
      }

    private:
    	static MethodInfo^ __IndexOf_Expr_String___Expr_int__Expr_int_;
    	static property MethodInfo^ _IndexOf_Expr_String___Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__IndexOf_Expr_String___Expr_int__Expr_int_ == nullptr) 
          __IndexOf_Expr_String___Expr_int__Expr_int_ = (String::typeid)->GetMethod("IndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<int>::WrappedType, Expr<int>::WrappedType }); return __IndexOf_Expr_String___Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Reports the index of the first occurrence of a String, or one or more characters, within this string.
      /// </summary>
      Expr<int> IndexOf(Expr<String^> value, Expr<int> startIndex, Expr<int> count)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_IndexOf_Expr_String___Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex, count}));
      }

    private:
    	static MethodInfo^ __LastIndexOf_Expr_wchar_t_;
    	static property MethodInfo^ _LastIndexOf_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__LastIndexOf_Expr_wchar_t_ == nullptr) 
          __LastIndexOf_Expr_wchar_t_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __LastIndexOf_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
      /// </summary>
      Expr<int> LastIndexOf(Expr<wchar_t> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_LastIndexOf_Expr_wchar_t_, this, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __LastIndexOf_Expr_String__;
    	static property MethodInfo^ _LastIndexOf_Expr_String__ { 
        MethodInfo^ get() { if (__LastIndexOf_Expr_String__ == nullptr) 
          __LastIndexOf_Expr_String__ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __LastIndexOf_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
      /// </summary>
      Expr<int> LastIndexOf(Expr<String^> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_LastIndexOf_Expr_String__, this, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __LastIndexOf_Expr_wchar_t__Expr_int_;
    	static property MethodInfo^ _LastIndexOf_Expr_wchar_t__Expr_int_ { 
        MethodInfo^ get() { if (__LastIndexOf_Expr_wchar_t__Expr_int_ == nullptr) 
          __LastIndexOf_Expr_wchar_t__Expr_int_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<int>::WrappedType }); return __LastIndexOf_Expr_wchar_t__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
      /// </summary>
      Expr<int> LastIndexOf(Expr<wchar_t> value, Expr<int> startIndex)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_LastIndexOf_Expr_wchar_t__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex}));
      }

    private:
    	static MethodInfo^ __LastIndexOf_Expr_String___Expr_int_;
    	static property MethodInfo^ _LastIndexOf_Expr_String___Expr_int_ { 
        MethodInfo^ get() { if (__LastIndexOf_Expr_String___Expr_int_ == nullptr) 
          __LastIndexOf_Expr_String___Expr_int_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<int>::WrappedType }); return __LastIndexOf_Expr_String___Expr_int_; 
        } }
    public:
      /// <summary>
      /// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
      /// </summary>
      Expr<int> LastIndexOf(Expr<String^> value, Expr<int> startIndex)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_LastIndexOf_Expr_String___Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex}));
      }

    private:
    	static MethodInfo^ __LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_;
    	static property MethodInfo^ _LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_ == nullptr) 
          __LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<int>::WrappedType, Expr<int>::WrappedType }); return __LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
      /// </summary>
      Expr<int> LastIndexOf(Expr<wchar_t> value, Expr<int> startIndex, Expr<int> count)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_LastIndexOf_Expr_wchar_t__Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex, count}));
      }

    private:
    	static MethodInfo^ __LastIndexOf_Expr_String___Expr_int__Expr_int_;
    	static property MethodInfo^ _LastIndexOf_Expr_String___Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__LastIndexOf_Expr_String___Expr_int__Expr_int_ == nullptr) 
          __LastIndexOf_Expr_String___Expr_int__Expr_int_ = (String::typeid)->GetMethod("LastIndexOf", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<int>::WrappedType, Expr<int>::WrappedType }); return __LastIndexOf_Expr_String___Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Reports the index position of the last occurrence of a specified Unicode character or String within this instance.
      /// </summary>
      Expr<int> LastIndexOf(Expr<String^> value, Expr<int> startIndex, Expr<int> count)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_LastIndexOf_Expr_String___Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{value, startIndex, count}));
      }

    private:
    	static MethodInfo^ __Insert_Expr_int__Expr_String__;
    	static property MethodInfo^ _Insert_Expr_int__Expr_String__ { 
        MethodInfo^ get() { if (__Insert_Expr_int__Expr_String__ == nullptr) 
          __Insert_Expr_int__Expr_String__ = (String::typeid)->GetMethod("Insert", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<String^>::WrappedType }); return __Insert_Expr_int__Expr_String__; 
        } }
    public:
      /// <summary>
      /// Inserts a specified instance of String at a specified index position in this instance.
      /// </summary>
      Expr<String^> Insert(Expr<int> startIndex, Expr<String^> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Insert_Expr_int__Expr_String__, this, gcnew array<GenericExpression^>{startIndex, value}));
      }

    private:
    	static MethodInfo^ __Remove_Expr_int_;
    	static property MethodInfo^ _Remove_Expr_int_ { 
        MethodInfo^ get() { if (__Remove_Expr_int_ == nullptr) 
          __Remove_Expr_int_ = (String::typeid)->GetMethod("Remove", gcnew array<Type^>{ Expr<int>::WrappedType }); return __Remove_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Deletes a specified number of characters from this instance.
      /// </summary>
      Expr<String^> Remove(Expr<int> startIndex)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Remove_Expr_int_, this, gcnew array<GenericExpression^>{startIndex}));
      }

    private:
    	static MethodInfo^ __Remove_Expr_int__Expr_int_;
    	static property MethodInfo^ _Remove_Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__Remove_Expr_int__Expr_int_ == nullptr) 
          __Remove_Expr_int__Expr_int_ = (String::typeid)->GetMethod("Remove", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __Remove_Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Deletes a specified number of characters from this instance.
      /// </summary>
      Expr<String^> Remove(Expr<int> startIndex, Expr<int> count)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Remove_Expr_int__Expr_int_, this, gcnew array<GenericExpression^>{startIndex, count}));
      }

    private:
    	static MethodInfo^ __Replace_Expr_wchar_t__Expr_wchar_t_;
    	static property MethodInfo^ _Replace_Expr_wchar_t__Expr_wchar_t_ { 
        MethodInfo^ get() { if (__Replace_Expr_wchar_t__Expr_wchar_t_ == nullptr) 
          __Replace_Expr_wchar_t__Expr_wchar_t_ = (String::typeid)->GetMethod("Replace", gcnew array<Type^>{ Expr<wchar_t>::WrappedType, Expr<wchar_t>::WrappedType }); return __Replace_Expr_wchar_t__Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Replaces all occurrences of a specified Unicode character or String in this instance, with another specified Unicode character or String.
      /// </summary>
      Expr<String^> Replace(Expr<wchar_t> oldChar, Expr<wchar_t> newChar)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Replace_Expr_wchar_t__Expr_wchar_t_, this, gcnew array<GenericExpression^>{oldChar, newChar}));
      }

    private:
    	static MethodInfo^ __Replace_Expr_String___Expr_String__;
    	static property MethodInfo^ _Replace_Expr_String___Expr_String__ { 
        MethodInfo^ get() { if (__Replace_Expr_String___Expr_String__ == nullptr) 
          __Replace_Expr_String___Expr_String__ = (String::typeid)->GetMethod("Replace", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<String^>::WrappedType }); return __Replace_Expr_String___Expr_String__; 
        } }
    public:
      /// <summary>
      /// Replaces all occurrences of a specified Unicode character or String in this instance, with another specified Unicode character or String.
      /// </summary>
      Expr<String^> Replace(Expr<String^> oldValue, Expr<String^> newValue)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Replace_Expr_String___Expr_String__, this, gcnew array<GenericExpression^>{oldValue, newValue}));
      }

    private:
    	static MethodInfo^ __Trim;
    	static property MethodInfo^ _Trim { 
        MethodInfo^ get() { if (__Trim == nullptr) 
          __Trim = (String::typeid)->GetMethod("Trim", gcnew array<Type^>{  }); return __Trim; 
        } }
    public:
      /// <summary>
      /// Removes all leading and trailing occurrences of a set of specified characters from the current String object.
      /// </summary>
      Expr<String^> Trim()
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Trim, this, gcnew array<GenericExpression^>{}));
      }

    private:
    	static MethodInfo^ __ToLower;
    	static property MethodInfo^ _ToLower { 
        MethodInfo^ get() { if (__ToLower == nullptr) 
          __ToLower = (String::typeid)->GetMethod("ToLower", gcnew array<Type^>{  }); return __ToLower; 
        } }
    public:
      /// <summary>
      /// Returns a copy of this String converted to lowercase.
      /// </summary>
      Expr<String^> ToLower()
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToLower, this, gcnew array<GenericExpression^>{}));
      }

    private:
    	static MethodInfo^ __ToUpper;
    	static property MethodInfo^ _ToUpper { 
        MethodInfo^ get() { if (__ToUpper == nullptr) 
          __ToUpper = (String::typeid)->GetMethod("ToUpper", gcnew array<Type^>{  }); return __ToUpper; 
        } }
    public:
      /// <summary>
      /// Returns a copy of this String converted to uppercase.
      /// </summary>
      Expr<String^> ToUpper()
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToUpper, this, gcnew array<GenericExpression^>{}));
      }

    private:
    	static MethodInfo^ __PadRight_Expr_int_;
    	static property MethodInfo^ _PadRight_Expr_int_ { 
        MethodInfo^ get() { if (__PadRight_Expr_int_ == nullptr) 
          __PadRight_Expr_int_ = (String::typeid)->GetMethod("PadRight", gcnew array<Type^>{ Expr<int>::WrappedType }); return __PadRight_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Left-aligns the characters in this string, padding on the right with spaces or a specified Unicode character, for a specified total length.
      /// </summary>
      Expr<String^> PadRight(Expr<int> totalWidth)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_PadRight_Expr_int_, this, gcnew array<GenericExpression^>{totalWidth}));
      }

    private:
    	static MethodInfo^ __PadRight_Expr_int__Expr_wchar_t_;
    	static property MethodInfo^ _PadRight_Expr_int__Expr_wchar_t_ { 
        MethodInfo^ get() { if (__PadRight_Expr_int__Expr_wchar_t_ == nullptr) 
          __PadRight_Expr_int__Expr_wchar_t_ = (String::typeid)->GetMethod("PadRight", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<wchar_t>::WrappedType }); return __PadRight_Expr_int__Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Left-aligns the characters in this string, padding on the right with spaces or a specified Unicode character, for a specified total length.
      /// </summary>
      Expr<String^> PadRight(Expr<int> totalWidth, Expr<wchar_t> paddingChar)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_PadRight_Expr_int__Expr_wchar_t_, this, gcnew array<GenericExpression^>{totalWidth, paddingChar}));
      }

    private:
    	static MethodInfo^ __PadLeft_Expr_int_;
    	static property MethodInfo^ _PadLeft_Expr_int_ { 
        MethodInfo^ get() { if (__PadLeft_Expr_int_ == nullptr) 
          __PadLeft_Expr_int_ = (String::typeid)->GetMethod("PadLeft", gcnew array<Type^>{ Expr<int>::WrappedType }); return __PadLeft_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Right-aligns the characters in this instance, padding on the left with spaces or a specified Unicode character for a specified total length.
      /// </summary>
      Expr<String^> PadLeft(Expr<int> totalWidth)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_PadLeft_Expr_int_, this, gcnew array<GenericExpression^>{totalWidth}));
      }

    private:
    	static MethodInfo^ __PadLeft_Expr_int__Expr_wchar_t_;
    	static property MethodInfo^ _PadLeft_Expr_int__Expr_wchar_t_ { 
        MethodInfo^ get() { if (__PadLeft_Expr_int__Expr_wchar_t_ == nullptr) 
          __PadLeft_Expr_int__Expr_wchar_t_ = (String::typeid)->GetMethod("PadLeft", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<wchar_t>::WrappedType }); return __PadLeft_Expr_int__Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Right-aligns the characters in this instance, padding on the left with spaces or a specified Unicode character for a specified total length.
      /// </summary>
      Expr<String^> PadLeft(Expr<int> totalWidth, Expr<wchar_t> paddingChar)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_PadLeft_Expr_int__Expr_wchar_t_, this, gcnew array<GenericExpression^>{totalWidth, paddingChar}));
      }

    private:
    	static MethodInfo^ __Equals_Expr_String__;
    	static property MethodInfo^ _Equals_Expr_String__ { 
        MethodInfo^ get() { if (__Equals_Expr_String__ == nullptr) 
          __Equals_Expr_String__ = (String::typeid)->GetMethod("Equals", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __Equals_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Determines whether two String objects have the same value.
      /// </summary>
      Expr<bool> Equals(Expr<String^> str)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_Equals_Expr_String__, this, gcnew array<GenericExpression^>{str}));
      }

    private:
    	static MethodInfo^ __CompareTo_Expr_String__;
    	static property MethodInfo^ _CompareTo_Expr_String__ { 
        MethodInfo^ get() { if (__CompareTo_Expr_String__ == nullptr) 
          __CompareTo_Expr_String__ = (String::typeid)->GetMethod("CompareTo", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __CompareTo_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Compares this instance with a specified object or String and returns an indication of their relative values.
      /// </summary>
      Expr<int> CompareTo(Expr<String^> str)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_CompareTo_Expr_String__, this, gcnew array<GenericExpression^>{str}));
      }

    private:
    	static MethodInfo^ __Compare_Expr_String___Expr_String__;
    	static property MethodInfo^ _Compare_Expr_String___Expr_String__ { 
        MethodInfo^ get() { if (__Compare_Expr_String___Expr_String__ == nullptr) 
          __Compare_Expr_String___Expr_String__ = (String::typeid)->GetMethod("Compare", gcnew array<Type^>{ Expr<String^>::WrappedType, Expr<String^>::WrappedType }); return __Compare_Expr_String___Expr_String__; 
        } }
    public:
      /// <summary>
      /// Compares two specified String objects.
      /// </summary>
      static Expr<int> Compare(Expr<String^> strA, Expr<String^> strB)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Compare_Expr_String___Expr_String__, nullptr, gcnew array<GenericExpression^>{strA, strB}));
      }

    private:
    	static MethodInfo^ __Concat_cli__array_Expression_String_____;
    	static property MethodInfo^ _Concat_cli__array_Expression_String_____ { 
        MethodInfo^ get() { if (__Concat_cli__array_Expression_String_____ == nullptr) 
          __Concat_cli__array_Expression_String_____ = (String::typeid)->GetMethod("Concat", gcnew array<Type^>{ cli::array<String^>::typeid }); return __Concat_cli__array_Expression_String_____; 
        } }
    public:
      /// <summary>
      /// Concatenates one or more instances of String.
      /// </summary>
      static Expr<String^> Concat(... cli::array<Expression<String^>^>^ strs)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_Concat_cli__array_Expression_String_____, nullptr, gcnew array<GenericExpression^>{ gcnew ParamsExpression<String^>(strs) }));
      }

    };
    

    /// <summary>
    /// Template specialization for the 'DateTime' expresion.
    /// </summary>
    template<> public ref class Expr<DateTime> : ExpressionWrapper<DateTime>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return DateTime::typeid; } }
    
		public:
			Expr<DateTime>() { }
      Expr<DateTime>(DateTime val) { _value = gcnew Literal<DateTime>(val); }
      Expr<DateTime>(Expression<DateTime>^ value) { _value = value; }
			Expr<DateTime>(Expr<DateTime>% b)	{ _value = b._value; }
			operator Expression<DateTime>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<DateTime>(Expression<DateTime>^ value)  { return Expr<DateTime>(value); }
			static operator Expr<DateTime>(DateTime b) { return Expr<DateTime>(b); }
      
      

    public:
    static Expr<DateTime> Typed(GenericExpression^ value) 
      { 
        return Expr<DateTime>(gcnew TypedExpression<DateTime>(value));
      }

      static Expr<DateTime> Convert(GenericExpression^ value) 
      { 
        return Expr<DateTime>(gcnew ConvertExpression<DateTime>(value));
      }

    public:
      
  
    public:
      
    };
    

    /// <summary>
    /// Template specialization for the 'Nullable<DateTime>' expresion.
    /// </summary>
    template<> public ref class Expr<Nullable<DateTime>> : ExpressionWrapper<Nullable<DateTime>>
    {
    public:
      static property Type^ WrappedType { Type^ get() { return Nullable<DateTime>::typeid; } }
    
		public:
			Expr<Nullable<DateTime>>() { }
      Expr<Nullable<DateTime>>(Nullable<DateTime> val) { _value = gcnew Literal<Nullable<DateTime>>(val); }
      Expr<Nullable<DateTime>>(Expression<Nullable<DateTime>>^ value) { _value = value; }
			Expr<Nullable<DateTime>>(Expr<Nullable<DateTime>>% b)	{ _value = b._value; }
			operator Expression<Nullable<DateTime>>^() { return _value; }
      operator GenericExpression^() { return _value; }
			static operator Expr<Nullable<DateTime>>(Expression<Nullable<DateTime>>^ value)  { return Expr<Nullable<DateTime>>(value); }
			static operator Expr<Nullable<DateTime>>(Nullable<DateTime> b) { return Expr<Nullable<DateTime>>(b); }
      
      

    public:
    static Expr<Nullable<DateTime>> Typed(GenericExpression^ value) 
      { 
        return Expr<Nullable<DateTime>>(gcnew TypedExpression<Nullable<DateTime>>(value));
      }

      static Expr<Nullable<DateTime>> Convert(GenericExpression^ value) 
      { 
        return Expr<Nullable<DateTime>>(gcnew ConvertExpression<Nullable<DateTime>>(value));
      }

    public:
      
  
    public:
      
    };
    

    /// <summary>
    /// Converts a base data type to another base data type.
    /// </summary>
    template<> public ref class Expr<System::Convert^>
    {
    private:
      Expr<System::Convert^>() { }
      
    public:
      
  
    public:
      
    private:
    	static MethodInfo^ __ToBool_Expr_bool_;
    	static property MethodInfo^ _ToBool_Expr_bool_ { 
        MethodInfo^ get() { if (__ToBool_Expr_bool_ == nullptr) 
          __ToBool_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToBool_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<bool> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_unsigned_char_;
    	static property MethodInfo^ _ToBool_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToBool_Expr_unsigned_char_ == nullptr) 
          __ToBool_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToBool_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<unsigned char> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_wchar_t_;
    	static property MethodInfo^ _ToBool_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToBool_Expr_wchar_t_ == nullptr) 
          __ToBool_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToBool_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<wchar_t> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_DateTime_;
    	static property MethodInfo^ _ToBool_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToBool_Expr_DateTime_ == nullptr) 
          __ToBool_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToBool_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<DateTime> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_Decimal_;
    	static property MethodInfo^ _ToBool_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToBool_Expr_Decimal_ == nullptr) 
          __ToBool_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToBool_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<Decimal> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_Double_;
    	static property MethodInfo^ _ToBool_Expr_Double_ { 
        MethodInfo^ get() { if (__ToBool_Expr_Double_ == nullptr) 
          __ToBool_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToBool_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<Double> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_float_;
    	static property MethodInfo^ _ToBool_Expr_float_ { 
        MethodInfo^ get() { if (__ToBool_Expr_float_ == nullptr) 
          __ToBool_Expr_float_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToBool_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<float> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_short_;
    	static property MethodInfo^ _ToBool_Expr_short_ { 
        MethodInfo^ get() { if (__ToBool_Expr_short_ == nullptr) 
          __ToBool_Expr_short_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToBool_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<short> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_int_;
    	static property MethodInfo^ _ToBool_Expr_int_ { 
        MethodInfo^ get() { if (__ToBool_Expr_int_ == nullptr) 
          __ToBool_Expr_int_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToBool_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<int> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_long_long_int_;
    	static property MethodInfo^ _ToBool_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToBool_Expr_long_long_int_ == nullptr) 
          __ToBool_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToBool_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<long long int> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToBool_Expr_String__;
    	static property MethodInfo^ _ToBool_Expr_String__ { 
        MethodInfo^ get() { if (__ToBool_Expr_String__ == nullptr) 
          __ToBool_Expr_String__ = (System::Convert::typeid)->GetMethod("ToBool", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToBool_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'bool'.
      /// </summary>
      static Expr<bool> ToBool(Expr<String^> value)
  		{
	  		return Expr<bool>(gcnew MethodInvokeExpression<bool>
          (_ToBool_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_bool_;
    	static property MethodInfo^ _ToByte_Expr_bool_ { 
        MethodInfo^ get() { if (__ToByte_Expr_bool_ == nullptr) 
          __ToByte_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToByte_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<bool> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_unsigned_char_;
    	static property MethodInfo^ _ToByte_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToByte_Expr_unsigned_char_ == nullptr) 
          __ToByte_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToByte_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<unsigned char> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_wchar_t_;
    	static property MethodInfo^ _ToByte_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToByte_Expr_wchar_t_ == nullptr) 
          __ToByte_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToByte_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<wchar_t> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_DateTime_;
    	static property MethodInfo^ _ToByte_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToByte_Expr_DateTime_ == nullptr) 
          __ToByte_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToByte_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<DateTime> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_Decimal_;
    	static property MethodInfo^ _ToByte_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToByte_Expr_Decimal_ == nullptr) 
          __ToByte_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToByte_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<Decimal> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_Double_;
    	static property MethodInfo^ _ToByte_Expr_Double_ { 
        MethodInfo^ get() { if (__ToByte_Expr_Double_ == nullptr) 
          __ToByte_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToByte_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<Double> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_float_;
    	static property MethodInfo^ _ToByte_Expr_float_ { 
        MethodInfo^ get() { if (__ToByte_Expr_float_ == nullptr) 
          __ToByte_Expr_float_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToByte_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<float> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_short_;
    	static property MethodInfo^ _ToByte_Expr_short_ { 
        MethodInfo^ get() { if (__ToByte_Expr_short_ == nullptr) 
          __ToByte_Expr_short_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToByte_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<short> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_int_;
    	static property MethodInfo^ _ToByte_Expr_int_ { 
        MethodInfo^ get() { if (__ToByte_Expr_int_ == nullptr) 
          __ToByte_Expr_int_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToByte_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<int> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_long_long_int_;
    	static property MethodInfo^ _ToByte_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToByte_Expr_long_long_int_ == nullptr) 
          __ToByte_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToByte_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<long long int> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToByte_Expr_String__;
    	static property MethodInfo^ _ToByte_Expr_String__ { 
        MethodInfo^ get() { if (__ToByte_Expr_String__ == nullptr) 
          __ToByte_Expr_String__ = (System::Convert::typeid)->GetMethod("ToByte", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToByte_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'unsigned char'.
      /// </summary>
      static Expr<unsigned char> ToByte(Expr<String^> value)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_ToByte_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_bool_;
    	static property MethodInfo^ _ToChar_Expr_bool_ { 
        MethodInfo^ get() { if (__ToChar_Expr_bool_ == nullptr) 
          __ToChar_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToChar_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<bool> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_unsigned_char_;
    	static property MethodInfo^ _ToChar_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToChar_Expr_unsigned_char_ == nullptr) 
          __ToChar_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToChar_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<unsigned char> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_wchar_t_;
    	static property MethodInfo^ _ToChar_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToChar_Expr_wchar_t_ == nullptr) 
          __ToChar_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToChar_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<wchar_t> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_DateTime_;
    	static property MethodInfo^ _ToChar_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToChar_Expr_DateTime_ == nullptr) 
          __ToChar_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToChar_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<DateTime> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_Decimal_;
    	static property MethodInfo^ _ToChar_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToChar_Expr_Decimal_ == nullptr) 
          __ToChar_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToChar_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<Decimal> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_Double_;
    	static property MethodInfo^ _ToChar_Expr_Double_ { 
        MethodInfo^ get() { if (__ToChar_Expr_Double_ == nullptr) 
          __ToChar_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToChar_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<Double> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_float_;
    	static property MethodInfo^ _ToChar_Expr_float_ { 
        MethodInfo^ get() { if (__ToChar_Expr_float_ == nullptr) 
          __ToChar_Expr_float_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToChar_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<float> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_short_;
    	static property MethodInfo^ _ToChar_Expr_short_ { 
        MethodInfo^ get() { if (__ToChar_Expr_short_ == nullptr) 
          __ToChar_Expr_short_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToChar_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<short> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_int_;
    	static property MethodInfo^ _ToChar_Expr_int_ { 
        MethodInfo^ get() { if (__ToChar_Expr_int_ == nullptr) 
          __ToChar_Expr_int_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToChar_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<int> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_long_long_int_;
    	static property MethodInfo^ _ToChar_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToChar_Expr_long_long_int_ == nullptr) 
          __ToChar_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToChar_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<long long int> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToChar_Expr_String__;
    	static property MethodInfo^ _ToChar_Expr_String__ { 
        MethodInfo^ get() { if (__ToChar_Expr_String__ == nullptr) 
          __ToChar_Expr_String__ = (System::Convert::typeid)->GetMethod("ToChar", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToChar_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'wchar_t'.
      /// </summary>
      static Expr<wchar_t> ToChar(Expr<String^> value)
  		{
	  		return Expr<wchar_t>(gcnew MethodInvokeExpression<wchar_t>
          (_ToChar_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_bool_;
    	static property MethodInfo^ _ToDateTime_Expr_bool_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_bool_ == nullptr) 
          __ToDateTime_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToDateTime_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<bool> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_unsigned_char_;
    	static property MethodInfo^ _ToDateTime_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_unsigned_char_ == nullptr) 
          __ToDateTime_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToDateTime_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<unsigned char> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_wchar_t_;
    	static property MethodInfo^ _ToDateTime_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_wchar_t_ == nullptr) 
          __ToDateTime_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToDateTime_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<wchar_t> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_DateTime_;
    	static property MethodInfo^ _ToDateTime_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_DateTime_ == nullptr) 
          __ToDateTime_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToDateTime_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<DateTime> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_Decimal_;
    	static property MethodInfo^ _ToDateTime_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_Decimal_ == nullptr) 
          __ToDateTime_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToDateTime_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<Decimal> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_Double_;
    	static property MethodInfo^ _ToDateTime_Expr_Double_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_Double_ == nullptr) 
          __ToDateTime_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToDateTime_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<Double> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_float_;
    	static property MethodInfo^ _ToDateTime_Expr_float_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_float_ == nullptr) 
          __ToDateTime_Expr_float_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToDateTime_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<float> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_short_;
    	static property MethodInfo^ _ToDateTime_Expr_short_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_short_ == nullptr) 
          __ToDateTime_Expr_short_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToDateTime_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<short> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_int_;
    	static property MethodInfo^ _ToDateTime_Expr_int_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_int_ == nullptr) 
          __ToDateTime_Expr_int_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToDateTime_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<int> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_long_long_int_;
    	static property MethodInfo^ _ToDateTime_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_long_long_int_ == nullptr) 
          __ToDateTime_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToDateTime_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<long long int> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDateTime_Expr_String__;
    	static property MethodInfo^ _ToDateTime_Expr_String__ { 
        MethodInfo^ get() { if (__ToDateTime_Expr_String__ == nullptr) 
          __ToDateTime_Expr_String__ = (System::Convert::typeid)->GetMethod("ToDateTime", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToDateTime_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'DateTime'.
      /// </summary>
      static Expr<DateTime> ToDateTime(Expr<String^> value)
  		{
	  		return Expr<DateTime>(gcnew MethodInvokeExpression<DateTime>
          (_ToDateTime_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_bool_;
    	static property MethodInfo^ _ToDecimal_Expr_bool_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_bool_ == nullptr) 
          __ToDecimal_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToDecimal_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<bool> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_unsigned_char_;
    	static property MethodInfo^ _ToDecimal_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_unsigned_char_ == nullptr) 
          __ToDecimal_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToDecimal_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<unsigned char> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_wchar_t_;
    	static property MethodInfo^ _ToDecimal_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_wchar_t_ == nullptr) 
          __ToDecimal_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToDecimal_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<wchar_t> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_DateTime_;
    	static property MethodInfo^ _ToDecimal_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_DateTime_ == nullptr) 
          __ToDecimal_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToDecimal_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<DateTime> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_Decimal_;
    	static property MethodInfo^ _ToDecimal_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_Decimal_ == nullptr) 
          __ToDecimal_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToDecimal_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<Decimal> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_Double_;
    	static property MethodInfo^ _ToDecimal_Expr_Double_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_Double_ == nullptr) 
          __ToDecimal_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToDecimal_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<Double> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_float_;
    	static property MethodInfo^ _ToDecimal_Expr_float_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_float_ == nullptr) 
          __ToDecimal_Expr_float_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToDecimal_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<float> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_short_;
    	static property MethodInfo^ _ToDecimal_Expr_short_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_short_ == nullptr) 
          __ToDecimal_Expr_short_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToDecimal_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<short> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_int_;
    	static property MethodInfo^ _ToDecimal_Expr_int_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_int_ == nullptr) 
          __ToDecimal_Expr_int_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToDecimal_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<int> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_long_long_int_;
    	static property MethodInfo^ _ToDecimal_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_long_long_int_ == nullptr) 
          __ToDecimal_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToDecimal_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<long long int> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDecimal_Expr_String__;
    	static property MethodInfo^ _ToDecimal_Expr_String__ { 
        MethodInfo^ get() { if (__ToDecimal_Expr_String__ == nullptr) 
          __ToDecimal_Expr_String__ = (System::Convert::typeid)->GetMethod("ToDecimal", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToDecimal_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'Decimal'.
      /// </summary>
      static Expr<Decimal> ToDecimal(Expr<String^> value)
  		{
	  		return Expr<Decimal>(gcnew MethodInvokeExpression<Decimal>
          (_ToDecimal_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_bool_;
    	static property MethodInfo^ _ToDouble_Expr_bool_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_bool_ == nullptr) 
          __ToDouble_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToDouble_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<bool> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_unsigned_char_;
    	static property MethodInfo^ _ToDouble_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_unsigned_char_ == nullptr) 
          __ToDouble_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToDouble_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<unsigned char> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_wchar_t_;
    	static property MethodInfo^ _ToDouble_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_wchar_t_ == nullptr) 
          __ToDouble_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToDouble_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<wchar_t> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_DateTime_;
    	static property MethodInfo^ _ToDouble_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_DateTime_ == nullptr) 
          __ToDouble_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToDouble_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<DateTime> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_Decimal_;
    	static property MethodInfo^ _ToDouble_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_Decimal_ == nullptr) 
          __ToDouble_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToDouble_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<Decimal> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_Double_;
    	static property MethodInfo^ _ToDouble_Expr_Double_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_Double_ == nullptr) 
          __ToDouble_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToDouble_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<Double> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_float_;
    	static property MethodInfo^ _ToDouble_Expr_float_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_float_ == nullptr) 
          __ToDouble_Expr_float_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToDouble_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<float> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_short_;
    	static property MethodInfo^ _ToDouble_Expr_short_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_short_ == nullptr) 
          __ToDouble_Expr_short_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToDouble_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<short> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_int_;
    	static property MethodInfo^ _ToDouble_Expr_int_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_int_ == nullptr) 
          __ToDouble_Expr_int_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToDouble_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<int> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_long_long_int_;
    	static property MethodInfo^ _ToDouble_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToDouble_Expr_long_long_int_ == nullptr) 
          __ToDouble_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToDouble_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<long long int> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToDouble_Expr_String__;
    	static property MethodInfo^ _ToDouble_Expr_String__ { 
        MethodInfo^ get() { if (__ToDouble_Expr_String__ == nullptr) 
          __ToDouble_Expr_String__ = (System::Convert::typeid)->GetMethod("ToDouble", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToDouble_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'double'.
      /// </summary>
      static Expr<double> ToDouble(Expr<String^> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_ToDouble_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_bool_;
    	static property MethodInfo^ _ToSingle_Expr_bool_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_bool_ == nullptr) 
          __ToSingle_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToSingle_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<bool> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_unsigned_char_;
    	static property MethodInfo^ _ToSingle_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_unsigned_char_ == nullptr) 
          __ToSingle_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToSingle_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<unsigned char> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_wchar_t_;
    	static property MethodInfo^ _ToSingle_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_wchar_t_ == nullptr) 
          __ToSingle_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToSingle_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<wchar_t> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_DateTime_;
    	static property MethodInfo^ _ToSingle_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_DateTime_ == nullptr) 
          __ToSingle_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToSingle_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<DateTime> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_Decimal_;
    	static property MethodInfo^ _ToSingle_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_Decimal_ == nullptr) 
          __ToSingle_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToSingle_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<Decimal> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_Double_;
    	static property MethodInfo^ _ToSingle_Expr_Double_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_Double_ == nullptr) 
          __ToSingle_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToSingle_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<Double> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_float_;
    	static property MethodInfo^ _ToSingle_Expr_float_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_float_ == nullptr) 
          __ToSingle_Expr_float_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToSingle_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<float> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_short_;
    	static property MethodInfo^ _ToSingle_Expr_short_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_short_ == nullptr) 
          __ToSingle_Expr_short_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToSingle_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<short> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_int_;
    	static property MethodInfo^ _ToSingle_Expr_int_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_int_ == nullptr) 
          __ToSingle_Expr_int_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToSingle_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<int> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_long_long_int_;
    	static property MethodInfo^ _ToSingle_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToSingle_Expr_long_long_int_ == nullptr) 
          __ToSingle_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToSingle_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<long long int> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToSingle_Expr_String__;
    	static property MethodInfo^ _ToSingle_Expr_String__ { 
        MethodInfo^ get() { if (__ToSingle_Expr_String__ == nullptr) 
          __ToSingle_Expr_String__ = (System::Convert::typeid)->GetMethod("ToSingle", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToSingle_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'float'.
      /// </summary>
      static Expr<float> ToSingle(Expr<String^> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_ToSingle_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_bool_;
    	static property MethodInfo^ _ToInt16_Expr_bool_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_bool_ == nullptr) 
          __ToInt16_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToInt16_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<bool> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_unsigned_char_;
    	static property MethodInfo^ _ToInt16_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_unsigned_char_ == nullptr) 
          __ToInt16_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToInt16_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<unsigned char> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_wchar_t_;
    	static property MethodInfo^ _ToInt16_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_wchar_t_ == nullptr) 
          __ToInt16_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToInt16_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<wchar_t> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_DateTime_;
    	static property MethodInfo^ _ToInt16_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_DateTime_ == nullptr) 
          __ToInt16_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToInt16_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<DateTime> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_Decimal_;
    	static property MethodInfo^ _ToInt16_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_Decimal_ == nullptr) 
          __ToInt16_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToInt16_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<Decimal> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_Double_;
    	static property MethodInfo^ _ToInt16_Expr_Double_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_Double_ == nullptr) 
          __ToInt16_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToInt16_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<Double> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_float_;
    	static property MethodInfo^ _ToInt16_Expr_float_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_float_ == nullptr) 
          __ToInt16_Expr_float_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToInt16_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<float> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_short_;
    	static property MethodInfo^ _ToInt16_Expr_short_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_short_ == nullptr) 
          __ToInt16_Expr_short_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToInt16_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<short> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_int_;
    	static property MethodInfo^ _ToInt16_Expr_int_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_int_ == nullptr) 
          __ToInt16_Expr_int_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToInt16_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<int> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_long_long_int_;
    	static property MethodInfo^ _ToInt16_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToInt16_Expr_long_long_int_ == nullptr) 
          __ToInt16_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToInt16_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<long long int> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt16_Expr_String__;
    	static property MethodInfo^ _ToInt16_Expr_String__ { 
        MethodInfo^ get() { if (__ToInt16_Expr_String__ == nullptr) 
          __ToInt16_Expr_String__ = (System::Convert::typeid)->GetMethod("ToInt16", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToInt16_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'short'.
      /// </summary>
      static Expr<short> ToInt16(Expr<String^> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_ToInt16_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_bool_;
    	static property MethodInfo^ _ToInt32_Expr_bool_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_bool_ == nullptr) 
          __ToInt32_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToInt32_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<bool> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_unsigned_char_;
    	static property MethodInfo^ _ToInt32_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_unsigned_char_ == nullptr) 
          __ToInt32_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToInt32_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<unsigned char> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_wchar_t_;
    	static property MethodInfo^ _ToInt32_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_wchar_t_ == nullptr) 
          __ToInt32_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToInt32_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<wchar_t> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_DateTime_;
    	static property MethodInfo^ _ToInt32_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_DateTime_ == nullptr) 
          __ToInt32_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToInt32_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<DateTime> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_Decimal_;
    	static property MethodInfo^ _ToInt32_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_Decimal_ == nullptr) 
          __ToInt32_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToInt32_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<Decimal> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_Double_;
    	static property MethodInfo^ _ToInt32_Expr_Double_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_Double_ == nullptr) 
          __ToInt32_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToInt32_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<Double> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_float_;
    	static property MethodInfo^ _ToInt32_Expr_float_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_float_ == nullptr) 
          __ToInt32_Expr_float_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToInt32_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<float> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_short_;
    	static property MethodInfo^ _ToInt32_Expr_short_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_short_ == nullptr) 
          __ToInt32_Expr_short_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToInt32_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<short> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_int_;
    	static property MethodInfo^ _ToInt32_Expr_int_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_int_ == nullptr) 
          __ToInt32_Expr_int_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToInt32_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<int> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_long_long_int_;
    	static property MethodInfo^ _ToInt32_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToInt32_Expr_long_long_int_ == nullptr) 
          __ToInt32_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToInt32_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<long long int> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt32_Expr_String__;
    	static property MethodInfo^ _ToInt32_Expr_String__ { 
        MethodInfo^ get() { if (__ToInt32_Expr_String__ == nullptr) 
          __ToInt32_Expr_String__ = (System::Convert::typeid)->GetMethod("ToInt32", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToInt32_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'int'.
      /// </summary>
      static Expr<int> ToInt32(Expr<String^> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_ToInt32_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_bool_;
    	static property MethodInfo^ _ToInt64_Expr_bool_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_bool_ == nullptr) 
          __ToInt64_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToInt64_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<bool> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_unsigned_char_;
    	static property MethodInfo^ _ToInt64_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_unsigned_char_ == nullptr) 
          __ToInt64_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToInt64_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<unsigned char> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_wchar_t_;
    	static property MethodInfo^ _ToInt64_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_wchar_t_ == nullptr) 
          __ToInt64_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToInt64_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<wchar_t> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_DateTime_;
    	static property MethodInfo^ _ToInt64_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_DateTime_ == nullptr) 
          __ToInt64_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToInt64_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<DateTime> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_Decimal_;
    	static property MethodInfo^ _ToInt64_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_Decimal_ == nullptr) 
          __ToInt64_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToInt64_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<Decimal> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_Double_;
    	static property MethodInfo^ _ToInt64_Expr_Double_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_Double_ == nullptr) 
          __ToInt64_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToInt64_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<Double> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_float_;
    	static property MethodInfo^ _ToInt64_Expr_float_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_float_ == nullptr) 
          __ToInt64_Expr_float_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToInt64_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<float> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_short_;
    	static property MethodInfo^ _ToInt64_Expr_short_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_short_ == nullptr) 
          __ToInt64_Expr_short_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToInt64_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<short> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_int_;
    	static property MethodInfo^ _ToInt64_Expr_int_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_int_ == nullptr) 
          __ToInt64_Expr_int_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToInt64_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<int> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_long_long_int_;
    	static property MethodInfo^ _ToInt64_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToInt64_Expr_long_long_int_ == nullptr) 
          __ToInt64_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToInt64_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<long long int> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToInt64_Expr_String__;
    	static property MethodInfo^ _ToInt64_Expr_String__ { 
        MethodInfo^ get() { if (__ToInt64_Expr_String__ == nullptr) 
          __ToInt64_Expr_String__ = (System::Convert::typeid)->GetMethod("ToInt64", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToInt64_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'long long int'.
      /// </summary>
      static Expr<long long int> ToInt64(Expr<String^> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_ToInt64_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_bool_;
    	static property MethodInfo^ _ToString_Expr_bool_ { 
        MethodInfo^ get() { if (__ToString_Expr_bool_ == nullptr) 
          __ToString_Expr_bool_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<bool>::WrappedType }); return __ToString_Expr_bool_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<bool> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_bool_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_unsigned_char_;
    	static property MethodInfo^ _ToString_Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__ToString_Expr_unsigned_char_ == nullptr) 
          __ToString_Expr_unsigned_char_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<unsigned char>::WrappedType }); return __ToString_Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<unsigned char> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_wchar_t_;
    	static property MethodInfo^ _ToString_Expr_wchar_t_ { 
        MethodInfo^ get() { if (__ToString_Expr_wchar_t_ == nullptr) 
          __ToString_Expr_wchar_t_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<wchar_t>::WrappedType }); return __ToString_Expr_wchar_t_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<wchar_t> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_wchar_t_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_DateTime_;
    	static property MethodInfo^ _ToString_Expr_DateTime_ { 
        MethodInfo^ get() { if (__ToString_Expr_DateTime_ == nullptr) 
          __ToString_Expr_DateTime_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<DateTime>::WrappedType }); return __ToString_Expr_DateTime_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<DateTime> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_DateTime_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_Decimal_;
    	static property MethodInfo^ _ToString_Expr_Decimal_ { 
        MethodInfo^ get() { if (__ToString_Expr_Decimal_ == nullptr) 
          __ToString_Expr_Decimal_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<Decimal>::WrappedType }); return __ToString_Expr_Decimal_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<Decimal> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_Double_;
    	static property MethodInfo^ _ToString_Expr_Double_ { 
        MethodInfo^ get() { if (__ToString_Expr_Double_ == nullptr) 
          __ToString_Expr_Double_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<Double>::WrappedType }); return __ToString_Expr_Double_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<Double> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_Double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_float_;
    	static property MethodInfo^ _ToString_Expr_float_ { 
        MethodInfo^ get() { if (__ToString_Expr_float_ == nullptr) 
          __ToString_Expr_float_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<float>::WrappedType }); return __ToString_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<float> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_short_;
    	static property MethodInfo^ _ToString_Expr_short_ { 
        MethodInfo^ get() { if (__ToString_Expr_short_ == nullptr) 
          __ToString_Expr_short_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<short>::WrappedType }); return __ToString_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<short> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_int_;
    	static property MethodInfo^ _ToString_Expr_int_ { 
        MethodInfo^ get() { if (__ToString_Expr_int_ == nullptr) 
          __ToString_Expr_int_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<int>::WrappedType }); return __ToString_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<int> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_long_long_int_;
    	static property MethodInfo^ _ToString_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__ToString_Expr_long_long_int_ == nullptr) 
          __ToString_Expr_long_long_int_ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __ToString_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<long long int> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __ToString_Expr_String__;
    	static property MethodInfo^ _ToString_Expr_String__ { 
        MethodInfo^ get() { if (__ToString_Expr_String__ == nullptr) 
          __ToString_Expr_String__ = (System::Convert::typeid)->GetMethod("ToString", gcnew array<Type^>{ Expr<String^>::WrappedType }); return __ToString_Expr_String__; 
        } }
    public:
      /// <summary>
      /// Overloaded. Converts a specified value to 'String^'.
      /// </summary>
      static Expr<String^> ToString(Expr<String^> value)
  		{
	  		return Expr<String^>(gcnew MethodInvokeExpression<String^>
          (_ToString_Expr_String__, nullptr, gcnew array<GenericExpression^>{value}));
      }

    };
    

    /// <summary>
    /// Provides constants and static methods for trigonometric, logarithmic, and other common mathematical functions.
    /// </summary>
    template<> public ref class Expr<System::Math^>
    {
    private:
      Expr<System::Math^>() { }
      
    public:
      
  
    public:
      
    private:
    	static MethodInfo^ __Abs_Expr_System__Decimal_;
    	static property MethodInfo^ _Abs_Expr_System__Decimal_ { 
        MethodInfo^ get() { if (__Abs_Expr_System__Decimal_ == nullptr) 
          __Abs_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Abs_Expr_System__Decimal_; 
        } }
    public:
      /// <summary>
      /// Returns the absolute value of a specified number.
      /// </summary>
      static Expr<System::Decimal> Abs(Expr<System::Decimal> value)
  		{
	  		return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
          (_Abs_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Abs_Expr_double_;
    	static property MethodInfo^ _Abs_Expr_double_ { 
        MethodInfo^ get() { if (__Abs_Expr_double_ == nullptr) 
          __Abs_Expr_double_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Abs_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the absolute value of a specified number.
      /// </summary>
      static Expr<double> Abs(Expr<double> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Abs_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Abs_Expr_float_;
    	static property MethodInfo^ _Abs_Expr_float_ { 
        MethodInfo^ get() { if (__Abs_Expr_float_ == nullptr) 
          __Abs_Expr_float_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<float>::WrappedType }); return __Abs_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Returns the absolute value of a specified number.
      /// </summary>
      static Expr<float> Abs(Expr<float> value)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_Abs_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Abs_Expr_int_;
    	static property MethodInfo^ _Abs_Expr_int_ { 
        MethodInfo^ get() { if (__Abs_Expr_int_ == nullptr) 
          __Abs_Expr_int_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<int>::WrappedType }); return __Abs_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Returns the absolute value of a specified number.
      /// </summary>
      static Expr<int> Abs(Expr<int> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Abs_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Abs_Expr_long_long_int_;
    	static property MethodInfo^ _Abs_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__Abs_Expr_long_long_int_ == nullptr) 
          __Abs_Expr_long_long_int_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __Abs_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Returns the absolute value of a specified number.
      /// </summary>
      static Expr<long long int> Abs(Expr<long long int> value)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_Abs_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Abs_Expr_signed_char_;
    	static property MethodInfo^ _Abs_Expr_signed_char_ { 
        MethodInfo^ get() { if (__Abs_Expr_signed_char_ == nullptr) 
          __Abs_Expr_signed_char_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<signed char>::WrappedType }); return __Abs_Expr_signed_char_; 
        } }
    public:
      /// <summary>
      /// Returns the absolute value of a specified number.
      /// </summary>
      static Expr<signed char> Abs(Expr<signed char> value)
  		{
	  		return Expr<signed char>(gcnew MethodInvokeExpression<signed char>
          (_Abs_Expr_signed_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Abs_Expr_short_;
    	static property MethodInfo^ _Abs_Expr_short_ { 
        MethodInfo^ get() { if (__Abs_Expr_short_ == nullptr) 
          __Abs_Expr_short_ = (System::Math::typeid)->GetMethod("Abs", gcnew array<Type^>{ Expr<short>::WrappedType }); return __Abs_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Returns the absolute value of a specified number.
      /// </summary>
      static Expr<short> Abs(Expr<short> value)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_Abs_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Acos_Expr_double_;
    	static property MethodInfo^ _Acos_Expr_double_ { 
        MethodInfo^ get() { if (__Acos_Expr_double_ == nullptr) 
          __Acos_Expr_double_ = (System::Math::typeid)->GetMethod("Acos", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Acos_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the angle whose cosine is the specified number.
      /// </summary>
      static Expr<double> Acos(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Acos_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Asin_Expr_double_;
    	static property MethodInfo^ _Asin_Expr_double_ { 
        MethodInfo^ get() { if (__Asin_Expr_double_ == nullptr) 
          __Asin_Expr_double_ = (System::Math::typeid)->GetMethod("Asin", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Asin_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the angle whose sine is the specified number.
      /// </summary>
      static Expr<double> Asin(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Asin_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Atan_Expr_double_;
    	static property MethodInfo^ _Atan_Expr_double_ { 
        MethodInfo^ get() { if (__Atan_Expr_double_ == nullptr) 
          __Atan_Expr_double_ = (System::Math::typeid)->GetMethod("Atan", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Atan_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the angle whose tangent is the specified number.
      /// </summary>
      static Expr<double> Atan(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Atan_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Atan2_Expr_double__Expr_double_;
    	static property MethodInfo^ _Atan2_Expr_double__Expr_double_ { 
        MethodInfo^ get() { if (__Atan2_Expr_double__Expr_double_ == nullptr) 
          __Atan2_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Atan2", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Atan2_Expr_double__Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the angle whose tangent is the quotient of two specified numbers.
      /// </summary>
      static Expr<double> Atan2(Expr<double> y, Expr<double> x)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Atan2_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{y, x}));
      }

    private:
    	static MethodInfo^ __BigMul_Expr_int__Expr_int_;
    	static property MethodInfo^ _BigMul_Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__BigMul_Expr_int__Expr_int_ == nullptr) 
          __BigMul_Expr_int__Expr_int_ = (System::Math::typeid)->GetMethod("BigMul", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __BigMul_Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Produces the full product of two 32-bit numbers.
      /// </summary>
      static Expr<long long int> BigMul(Expr<int> a, Expr<int> b)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_BigMul_Expr_int__Expr_int_, nullptr, gcnew array<GenericExpression^>{a, b}));
      }

    private:
    	static MethodInfo^ __Ceiling_Expr_System__Decimal_;
    	static property MethodInfo^ _Ceiling_Expr_System__Decimal_ { 
        MethodInfo^ get() { if (__Ceiling_Expr_System__Decimal_ == nullptr) 
          __Ceiling_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Ceiling", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Ceiling_Expr_System__Decimal_; 
        } }
    public:
      /// <summary>
      /// Returns the smallest number greater than or equal to the specified number.
      /// </summary>
      static Expr<System::Decimal> Ceiling(Expr<System::Decimal> d)
  		{
	  		return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
          (_Ceiling_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Ceiling_Expr_double_;
    	static property MethodInfo^ _Ceiling_Expr_double_ { 
        MethodInfo^ get() { if (__Ceiling_Expr_double_ == nullptr) 
          __Ceiling_Expr_double_ = (System::Math::typeid)->GetMethod("Ceiling", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Ceiling_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the smallest number greater than or equal to the specified number.
      /// </summary>
      static Expr<double> Ceiling(Expr<double> a)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Ceiling_Expr_double_, nullptr, gcnew array<GenericExpression^>{a}));
      }

    private:
    	static MethodInfo^ __Cos_Expr_double_;
    	static property MethodInfo^ _Cos_Expr_double_ { 
        MethodInfo^ get() { if (__Cos_Expr_double_ == nullptr) 
          __Cos_Expr_double_ = (System::Math::typeid)->GetMethod("Cos", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Cos_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the cosine of the specified angle.
      /// </summary>
      static Expr<double> Cos(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Cos_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Cosh_Expr_double_;
    	static property MethodInfo^ _Cosh_Expr_double_ { 
        MethodInfo^ get() { if (__Cosh_Expr_double_ == nullptr) 
          __Cosh_Expr_double_ = (System::Math::typeid)->GetMethod("Cosh", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Cosh_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the hyperbolic cosine of the specified angle.
      /// </summary>
      static Expr<double> Cosh(Expr<double> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Cosh_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Exp_Expr_double_;
    	static property MethodInfo^ _Exp_Expr_double_ { 
        MethodInfo^ get() { if (__Exp_Expr_double_ == nullptr) 
          __Exp_Expr_double_ = (System::Math::typeid)->GetMethod("Exp", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Exp_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns e raised to the specified power.
      /// </summary>
      static Expr<double> Exp(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Exp_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Floor_Expr_System__Decimal_;
    	static property MethodInfo^ _Floor_Expr_System__Decimal_ { 
        MethodInfo^ get() { if (__Floor_Expr_System__Decimal_ == nullptr) 
          __Floor_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Floor", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Floor_Expr_System__Decimal_; 
        } }
    public:
      /// <summary>
      /// Returns the largest number less than or equal to the specified number.
      /// </summary>
      static Expr<System::Decimal> Floor(Expr<System::Decimal> d)
  		{
	  		return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
          (_Floor_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Floor_Expr_double_;
    	static property MethodInfo^ _Floor_Expr_double_ { 
        MethodInfo^ get() { if (__Floor_Expr_double_ == nullptr) 
          __Floor_Expr_double_ = (System::Math::typeid)->GetMethod("Floor", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Floor_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the largest number less than or equal to the specified number.
      /// </summary>
      static Expr<double> Floor(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Floor_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Log_Expr_double_;
    	static property MethodInfo^ _Log_Expr_double_ { 
        MethodInfo^ get() { if (__Log_Expr_double_ == nullptr) 
          __Log_Expr_double_ = (System::Math::typeid)->GetMethod("Log", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Log_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the logarithm of a specified number.
      /// </summary>
      static Expr<double> Log(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Log_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Log_Expr_double__Expr_double_;
    	static property MethodInfo^ _Log_Expr_double__Expr_double_ { 
        MethodInfo^ get() { if (__Log_Expr_double__Expr_double_ == nullptr) 
          __Log_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Log", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Log_Expr_double__Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the logarithm of a specified number.
      /// </summary>
      static Expr<double> Log(Expr<double> a, Expr<double> newBase)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Log_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{a, newBase}));
      }

    private:
    	static MethodInfo^ __Log10_Expr_double_;
    	static property MethodInfo^ _Log10_Expr_double_ { 
        MethodInfo^ get() { if (__Log10_Expr_double_ == nullptr) 
          __Log10_Expr_double_ = (System::Math::typeid)->GetMethod("Log10", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Log10_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Log10  Returns the base 10 logarithm of a specified number.
      /// </summary>
      static Expr<double> Log10(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Log10_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Max_Expr_unsigned_char__Expr_unsigned_char_;
    	static property MethodInfo^ _Max_Expr_unsigned_char__Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__Max_Expr_unsigned_char__Expr_unsigned_char_ == nullptr) 
          __Max_Expr_unsigned_char__Expr_unsigned_char_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<unsigned char>::WrappedType, Expr<unsigned char>::WrappedType }); return __Max_Expr_unsigned_char__Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<unsigned char> Max(Expr<unsigned char> val1, Expr<unsigned char> val2)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_Max_Expr_unsigned_char__Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_System__Decimal__Expr_System__Decimal_;
    	static property MethodInfo^ _Max_Expr_System__Decimal__Expr_System__Decimal_ { 
        MethodInfo^ get() { if (__Max_Expr_System__Decimal__Expr_System__Decimal_ == nullptr) 
          __Max_Expr_System__Decimal__Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType, Expr<System::Decimal>::WrappedType }); return __Max_Expr_System__Decimal__Expr_System__Decimal_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<System::Decimal> Max(Expr<System::Decimal> val1, Expr<System::Decimal> val2)
  		{
	  		return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
          (_Max_Expr_System__Decimal__Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_double__Expr_double_;
    	static property MethodInfo^ _Max_Expr_double__Expr_double_ { 
        MethodInfo^ get() { if (__Max_Expr_double__Expr_double_ == nullptr) 
          __Max_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Max_Expr_double__Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<double> Max(Expr<double> val1, Expr<double> val2)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Max_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_float__Expr_float_;
    	static property MethodInfo^ _Max_Expr_float__Expr_float_ { 
        MethodInfo^ get() { if (__Max_Expr_float__Expr_float_ == nullptr) 
          __Max_Expr_float__Expr_float_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<float>::WrappedType, Expr<float>::WrappedType }); return __Max_Expr_float__Expr_float_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<float> Max(Expr<float> val1, Expr<float> val2)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_Max_Expr_float__Expr_float_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_int__Expr_int_;
    	static property MethodInfo^ _Max_Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__Max_Expr_int__Expr_int_ == nullptr) 
          __Max_Expr_int__Expr_int_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __Max_Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<int> Max(Expr<int> val1, Expr<int> val2)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Max_Expr_int__Expr_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_long_long_int__Expr_long_long_int_;
    	static property MethodInfo^ _Max_Expr_long_long_int__Expr_long_long_int_ { 
        MethodInfo^ get() { if (__Max_Expr_long_long_int__Expr_long_long_int_ == nullptr) 
          __Max_Expr_long_long_int__Expr_long_long_int_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<long long int>::WrappedType, Expr<long long int>::WrappedType }); return __Max_Expr_long_long_int__Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<long long int> Max(Expr<long long int> val1, Expr<long long int> val2)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_Max_Expr_long_long_int__Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_signed_char__Expr_signed_char_;
    	static property MethodInfo^ _Max_Expr_signed_char__Expr_signed_char_ { 
        MethodInfo^ get() { if (__Max_Expr_signed_char__Expr_signed_char_ == nullptr) 
          __Max_Expr_signed_char__Expr_signed_char_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<signed char>::WrappedType, Expr<signed char>::WrappedType }); return __Max_Expr_signed_char__Expr_signed_char_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<signed char> Max(Expr<signed char> val1, Expr<signed char> val2)
  		{
	  		return Expr<signed char>(gcnew MethodInvokeExpression<signed char>
          (_Max_Expr_signed_char__Expr_signed_char_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_short__Expr_short_;
    	static property MethodInfo^ _Max_Expr_short__Expr_short_ { 
        MethodInfo^ get() { if (__Max_Expr_short__Expr_short_ == nullptr) 
          __Max_Expr_short__Expr_short_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<short>::WrappedType, Expr<short>::WrappedType }); return __Max_Expr_short__Expr_short_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<short> Max(Expr<short> val1, Expr<short> val2)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_Max_Expr_short__Expr_short_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_unsigned_int__Expr_unsigned_int_;
    	static property MethodInfo^ _Max_Expr_unsigned_int__Expr_unsigned_int_ { 
        MethodInfo^ get() { if (__Max_Expr_unsigned_int__Expr_unsigned_int_ == nullptr) 
          __Max_Expr_unsigned_int__Expr_unsigned_int_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<unsigned int>::WrappedType, Expr<unsigned int>::WrappedType }); return __Max_Expr_unsigned_int__Expr_unsigned_int_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<unsigned int> Max(Expr<unsigned int> val1, Expr<unsigned int> val2)
  		{
	  		return Expr<unsigned int>(gcnew MethodInvokeExpression<unsigned int>
          (_Max_Expr_unsigned_int__Expr_unsigned_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_;
    	static property MethodInfo^ _Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ { 
        MethodInfo^ get() { if (__Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ == nullptr) 
          __Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<unsigned long long int>::WrappedType, Expr<unsigned long long int>::WrappedType }); return __Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<unsigned long long int> Max(Expr<unsigned long long int> val1, Expr<unsigned long long int> val2)
  		{
	  		return Expr<unsigned long long int>(gcnew MethodInvokeExpression<unsigned long long int>
          (_Max_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Max_Expr_unsigned_short__Expr_unsigned_short_;
    	static property MethodInfo^ _Max_Expr_unsigned_short__Expr_unsigned_short_ { 
        MethodInfo^ get() { if (__Max_Expr_unsigned_short__Expr_unsigned_short_ == nullptr) 
          __Max_Expr_unsigned_short__Expr_unsigned_short_ = (System::Math::typeid)->GetMethod("Max", gcnew array<Type^>{ Expr<unsigned short>::WrappedType, Expr<unsigned short>::WrappedType }); return __Max_Expr_unsigned_short__Expr_unsigned_short_; 
        } }
    public:
      /// <summary>
      /// Returns the larger of two specified numbers.
      /// </summary>
      static Expr<unsigned short> Max(Expr<unsigned short> val1, Expr<unsigned short> val2)
  		{
	  		return Expr<unsigned short>(gcnew MethodInvokeExpression<unsigned short>
          (_Max_Expr_unsigned_short__Expr_unsigned_short_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_unsigned_char__Expr_unsigned_char_;
    	static property MethodInfo^ _Min_Expr_unsigned_char__Expr_unsigned_char_ { 
        MethodInfo^ get() { if (__Min_Expr_unsigned_char__Expr_unsigned_char_ == nullptr) 
          __Min_Expr_unsigned_char__Expr_unsigned_char_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<unsigned char>::WrappedType, Expr<unsigned char>::WrappedType }); return __Min_Expr_unsigned_char__Expr_unsigned_char_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<unsigned char> Min(Expr<unsigned char> val1, Expr<unsigned char> val2)
  		{
	  		return Expr<unsigned char>(gcnew MethodInvokeExpression<unsigned char>
          (_Min_Expr_unsigned_char__Expr_unsigned_char_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_System__Decimal__Expr_System__Decimal_;
    	static property MethodInfo^ _Min_Expr_System__Decimal__Expr_System__Decimal_ { 
        MethodInfo^ get() { if (__Min_Expr_System__Decimal__Expr_System__Decimal_ == nullptr) 
          __Min_Expr_System__Decimal__Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType, Expr<System::Decimal>::WrappedType }); return __Min_Expr_System__Decimal__Expr_System__Decimal_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<System::Decimal> Min(Expr<System::Decimal> val1, Expr<System::Decimal> val2)
  		{
	  		return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
          (_Min_Expr_System__Decimal__Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_double__Expr_double_;
    	static property MethodInfo^ _Min_Expr_double__Expr_double_ { 
        MethodInfo^ get() { if (__Min_Expr_double__Expr_double_ == nullptr) 
          __Min_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Min_Expr_double__Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<double> Min(Expr<double> val1, Expr<double> val2)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Min_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_float__Expr_float_;
    	static property MethodInfo^ _Min_Expr_float__Expr_float_ { 
        MethodInfo^ get() { if (__Min_Expr_float__Expr_float_ == nullptr) 
          __Min_Expr_float__Expr_float_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<float>::WrappedType, Expr<float>::WrappedType }); return __Min_Expr_float__Expr_float_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<float> Min(Expr<float> val1, Expr<float> val2)
  		{
	  		return Expr<float>(gcnew MethodInvokeExpression<float>
          (_Min_Expr_float__Expr_float_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_int__Expr_int_;
    	static property MethodInfo^ _Min_Expr_int__Expr_int_ { 
        MethodInfo^ get() { if (__Min_Expr_int__Expr_int_ == nullptr) 
          __Min_Expr_int__Expr_int_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<int>::WrappedType, Expr<int>::WrappedType }); return __Min_Expr_int__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<int> Min(Expr<int> val1, Expr<int> val2)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Min_Expr_int__Expr_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_long_long_int__Expr_long_long_int_;
    	static property MethodInfo^ _Min_Expr_long_long_int__Expr_long_long_int_ { 
        MethodInfo^ get() { if (__Min_Expr_long_long_int__Expr_long_long_int_ == nullptr) 
          __Min_Expr_long_long_int__Expr_long_long_int_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<long long int>::WrappedType, Expr<long long int>::WrappedType }); return __Min_Expr_long_long_int__Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<long long int> Min(Expr<long long int> val1, Expr<long long int> val2)
  		{
	  		return Expr<long long int>(gcnew MethodInvokeExpression<long long int>
          (_Min_Expr_long_long_int__Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_signed_char__Expr_signed_char_;
    	static property MethodInfo^ _Min_Expr_signed_char__Expr_signed_char_ { 
        MethodInfo^ get() { if (__Min_Expr_signed_char__Expr_signed_char_ == nullptr) 
          __Min_Expr_signed_char__Expr_signed_char_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<signed char>::WrappedType, Expr<signed char>::WrappedType }); return __Min_Expr_signed_char__Expr_signed_char_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<signed char> Min(Expr<signed char> val1, Expr<signed char> val2)
  		{
	  		return Expr<signed char>(gcnew MethodInvokeExpression<signed char>
          (_Min_Expr_signed_char__Expr_signed_char_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_short__Expr_short_;
    	static property MethodInfo^ _Min_Expr_short__Expr_short_ { 
        MethodInfo^ get() { if (__Min_Expr_short__Expr_short_ == nullptr) 
          __Min_Expr_short__Expr_short_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<short>::WrappedType, Expr<short>::WrappedType }); return __Min_Expr_short__Expr_short_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<short> Min(Expr<short> val1, Expr<short> val2)
  		{
	  		return Expr<short>(gcnew MethodInvokeExpression<short>
          (_Min_Expr_short__Expr_short_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_unsigned_int__Expr_unsigned_int_;
    	static property MethodInfo^ _Min_Expr_unsigned_int__Expr_unsigned_int_ { 
        MethodInfo^ get() { if (__Min_Expr_unsigned_int__Expr_unsigned_int_ == nullptr) 
          __Min_Expr_unsigned_int__Expr_unsigned_int_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<unsigned int>::WrappedType, Expr<unsigned int>::WrappedType }); return __Min_Expr_unsigned_int__Expr_unsigned_int_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<unsigned int> Min(Expr<unsigned int> val1, Expr<unsigned int> val2)
  		{
	  		return Expr<unsigned int>(gcnew MethodInvokeExpression<unsigned int>
          (_Min_Expr_unsigned_int__Expr_unsigned_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_;
    	static property MethodInfo^ _Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ { 
        MethodInfo^ get() { if (__Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ == nullptr) 
          __Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<unsigned long long int>::WrappedType, Expr<unsigned long long int>::WrappedType }); return __Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<unsigned long long int> Min(Expr<unsigned long long int> val1, Expr<unsigned long long int> val2)
  		{
	  		return Expr<unsigned long long int>(gcnew MethodInvokeExpression<unsigned long long int>
          (_Min_Expr_unsigned_long_long_int__Expr_unsigned_long_long_int_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Min_Expr_unsigned_short__Expr_unsigned_short_;
    	static property MethodInfo^ _Min_Expr_unsigned_short__Expr_unsigned_short_ { 
        MethodInfo^ get() { if (__Min_Expr_unsigned_short__Expr_unsigned_short_ == nullptr) 
          __Min_Expr_unsigned_short__Expr_unsigned_short_ = (System::Math::typeid)->GetMethod("Min", gcnew array<Type^>{ Expr<unsigned short>::WrappedType, Expr<unsigned short>::WrappedType }); return __Min_Expr_unsigned_short__Expr_unsigned_short_; 
        } }
    public:
      /// <summary>
      /// Returns the smaller of two numbers.
      /// </summary>
      static Expr<unsigned short> Min(Expr<unsigned short> val1, Expr<unsigned short> val2)
  		{
	  		return Expr<unsigned short>(gcnew MethodInvokeExpression<unsigned short>
          (_Min_Expr_unsigned_short__Expr_unsigned_short_, nullptr, gcnew array<GenericExpression^>{val1, val2}));
      }

    private:
    	static MethodInfo^ __Pow_Expr_double__Expr_double_;
    	static property MethodInfo^ _Pow_Expr_double__Expr_double_ { 
        MethodInfo^ get() { if (__Pow_Expr_double__Expr_double_ == nullptr) 
          __Pow_Expr_double__Expr_double_ = (System::Math::typeid)->GetMethod("Pow", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<double>::WrappedType }); return __Pow_Expr_double__Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns a specified number raised to the specified power.
      /// </summary>
      static Expr<double> Pow(Expr<double> x, Expr<double> y)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Pow_Expr_double__Expr_double_, nullptr, gcnew array<GenericExpression^>{x, y}));
      }

    private:
    	static MethodInfo^ __Round_Expr_System__Decimal_;
    	static property MethodInfo^ _Round_Expr_System__Decimal_ { 
        MethodInfo^ get() { if (__Round_Expr_System__Decimal_ == nullptr) 
          __Round_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Round", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Round_Expr_System__Decimal_; 
        } }
    public:
      /// <summary>
      /// Rounds a value to the nearest number or specified number of Expr<System::Decimal> places.
      /// </summary>
      static Expr<System::Decimal> Round(Expr<System::Decimal> d)
  		{
	  		return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
          (_Round_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Round_Expr_double_;
    	static property MethodInfo^ _Round_Expr_double_ { 
        MethodInfo^ get() { if (__Round_Expr_double_ == nullptr) 
          __Round_Expr_double_ = (System::Math::typeid)->GetMethod("Round", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Round_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Rounds a value to the nearest number or specified number of Expr<System::Decimal> places.
      /// </summary>
      static Expr<double> Round(Expr<double> a)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Round_Expr_double_, nullptr, gcnew array<GenericExpression^>{a}));
      }

    private:
    	static MethodInfo^ __Round_Expr_System__Decimal__Expr_int_;
    	static property MethodInfo^ _Round_Expr_System__Decimal__Expr_int_ { 
        MethodInfo^ get() { if (__Round_Expr_System__Decimal__Expr_int_ == nullptr) 
          __Round_Expr_System__Decimal__Expr_int_ = (System::Math::typeid)->GetMethod("Round", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType, Expr<int>::WrappedType }); return __Round_Expr_System__Decimal__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Rounds a value to the nearest number or specified number of Expr<System::Decimal> places.
      /// </summary>
      static Expr<System::Decimal> Round(Expr<System::Decimal> d, Expr<int> decimals)
  		{
	  		return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
          (_Round_Expr_System__Decimal__Expr_int_, nullptr, gcnew array<GenericExpression^>{d, decimals}));
      }

    private:
    	static MethodInfo^ __Round_Expr_double__Expr_int_;
    	static property MethodInfo^ _Round_Expr_double__Expr_int_ { 
        MethodInfo^ get() { if (__Round_Expr_double__Expr_int_ == nullptr) 
          __Round_Expr_double__Expr_int_ = (System::Math::typeid)->GetMethod("Round", gcnew array<Type^>{ Expr<double>::WrappedType, Expr<int>::WrappedType }); return __Round_Expr_double__Expr_int_; 
        } }
    public:
      /// <summary>
      /// Rounds a value to the nearest number or specified number of Expr<System::Decimal> places.
      /// </summary>
      static Expr<double> Round(Expr<double> value, Expr<int> digits)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Round_Expr_double__Expr_int_, nullptr, gcnew array<GenericExpression^>{value, digits}));
      }

    private:
    	static MethodInfo^ __Sign_Expr_System__Decimal_;
    	static property MethodInfo^ _Sign_Expr_System__Decimal_ { 
        MethodInfo^ get() { if (__Sign_Expr_System__Decimal_ == nullptr) 
          __Sign_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Sign_Expr_System__Decimal_; 
        } }
    public:
      /// <summary>
      /// Returns a value indicating the sign of a number.
      /// </summary>
      static Expr<int> Sign(Expr<System::Decimal> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Sign_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Sign_Expr_double_;
    	static property MethodInfo^ _Sign_Expr_double_ { 
        MethodInfo^ get() { if (__Sign_Expr_double_ == nullptr) 
          __Sign_Expr_double_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Sign_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns a value indicating the sign of a number.
      /// </summary>
      static Expr<int> Sign(Expr<double> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Sign_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Sign_Expr_float_;
    	static property MethodInfo^ _Sign_Expr_float_ { 
        MethodInfo^ get() { if (__Sign_Expr_float_ == nullptr) 
          __Sign_Expr_float_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<float>::WrappedType }); return __Sign_Expr_float_; 
        } }
    public:
      /// <summary>
      /// Returns a value indicating the sign of a number.
      /// </summary>
      static Expr<int> Sign(Expr<float> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Sign_Expr_float_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Sign_Expr_int_;
    	static property MethodInfo^ _Sign_Expr_int_ { 
        MethodInfo^ get() { if (__Sign_Expr_int_ == nullptr) 
          __Sign_Expr_int_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<int>::WrappedType }); return __Sign_Expr_int_; 
        } }
    public:
      /// <summary>
      /// Returns a value indicating the sign of a number.
      /// </summary>
      static Expr<int> Sign(Expr<int> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Sign_Expr_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Sign_Expr_long_long_int_;
    	static property MethodInfo^ _Sign_Expr_long_long_int_ { 
        MethodInfo^ get() { if (__Sign_Expr_long_long_int_ == nullptr) 
          __Sign_Expr_long_long_int_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<long long int>::WrappedType }); return __Sign_Expr_long_long_int_; 
        } }
    public:
      /// <summary>
      /// Returns a value indicating the sign of a number.
      /// </summary>
      static Expr<int> Sign(Expr<long long int> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Sign_Expr_long_long_int_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Sign_Expr_signed_char_;
    	static property MethodInfo^ _Sign_Expr_signed_char_ { 
        MethodInfo^ get() { if (__Sign_Expr_signed_char_ == nullptr) 
          __Sign_Expr_signed_char_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<signed char>::WrappedType }); return __Sign_Expr_signed_char_; 
        } }
    public:
      /// <summary>
      /// Returns a value indicating the sign of a number.
      /// </summary>
      static Expr<int> Sign(Expr<signed char> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Sign_Expr_signed_char_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Sign_Expr_short_;
    	static property MethodInfo^ _Sign_Expr_short_ { 
        MethodInfo^ get() { if (__Sign_Expr_short_ == nullptr) 
          __Sign_Expr_short_ = (System::Math::typeid)->GetMethod("Sign", gcnew array<Type^>{ Expr<short>::WrappedType }); return __Sign_Expr_short_; 
        } }
    public:
      /// <summary>
      /// Returns a value indicating the sign of a number.
      /// </summary>
      static Expr<int> Sign(Expr<short> value)
  		{
	  		return Expr<int>(gcnew MethodInvokeExpression<int>
          (_Sign_Expr_short_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Sin_Expr_double_;
    	static property MethodInfo^ _Sin_Expr_double_ { 
        MethodInfo^ get() { if (__Sin_Expr_double_ == nullptr) 
          __Sin_Expr_double_ = (System::Math::typeid)->GetMethod("Sin", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Sin_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the sine of the specified angle.
      /// </summary>
      static Expr<double> Sin(Expr<double> a)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Sin_Expr_double_, nullptr, gcnew array<GenericExpression^>{a}));
      }

    private:
    	static MethodInfo^ __Sinh_Expr_double_;
    	static property MethodInfo^ _Sinh_Expr_double_ { 
        MethodInfo^ get() { if (__Sinh_Expr_double_ == nullptr) 
          __Sinh_Expr_double_ = (System::Math::typeid)->GetMethod("Sinh", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Sinh_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the hyperbolic sine of the specified angle.
      /// </summary>
      static Expr<double> Sinh(Expr<double> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Sinh_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Sqrt_Expr_double_;
    	static property MethodInfo^ _Sqrt_Expr_double_ { 
        MethodInfo^ get() { if (__Sqrt_Expr_double_ == nullptr) 
          __Sqrt_Expr_double_ = (System::Math::typeid)->GetMethod("Sqrt", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Sqrt_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the square root of a specified number.
      /// </summary>
      static Expr<double> Sqrt(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Sqrt_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Tan_Expr_double_;
    	static property MethodInfo^ _Tan_Expr_double_ { 
        MethodInfo^ get() { if (__Tan_Expr_double_ == nullptr) 
          __Tan_Expr_double_ = (System::Math::typeid)->GetMethod("Tan", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Tan_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the tangent of the specified angle.
      /// </summary>
      static Expr<double> Tan(Expr<double> a)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Tan_Expr_double_, nullptr, gcnew array<GenericExpression^>{a}));
      }

    private:
    	static MethodInfo^ __Tanh_Expr_double_;
    	static property MethodInfo^ _Tanh_Expr_double_ { 
        MethodInfo^ get() { if (__Tanh_Expr_double_ == nullptr) 
          __Tanh_Expr_double_ = (System::Math::typeid)->GetMethod("Tanh", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Tanh_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Returns the hyperbolic tangent of the specified angle.
      /// </summary>
      static Expr<double> Tanh(Expr<double> value)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Tanh_Expr_double_, nullptr, gcnew array<GenericExpression^>{value}));
      }

    private:
    	static MethodInfo^ __Truncate_Expr_System__Decimal_;
    	static property MethodInfo^ _Truncate_Expr_System__Decimal_ { 
        MethodInfo^ get() { if (__Truncate_Expr_System__Decimal_ == nullptr) 
          __Truncate_Expr_System__Decimal_ = (System::Math::typeid)->GetMethod("Truncate", gcnew array<Type^>{ Expr<System::Decimal>::WrappedType }); return __Truncate_Expr_System__Decimal_; 
        } }
    public:
      /// <summary>
      /// Calculates the integral part of a number.
      /// </summary>
      static Expr<System::Decimal> Truncate(Expr<System::Decimal> d)
  		{
	  		return Expr<System::Decimal>(gcnew MethodInvokeExpression<System::Decimal>
          (_Truncate_Expr_System__Decimal_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    private:
    	static MethodInfo^ __Truncate_Expr_double_;
    	static property MethodInfo^ _Truncate_Expr_double_ { 
        MethodInfo^ get() { if (__Truncate_Expr_double_ == nullptr) 
          __Truncate_Expr_double_ = (System::Math::typeid)->GetMethod("Truncate", gcnew array<Type^>{ Expr<double>::WrappedType }); return __Truncate_Expr_double_; 
        } }
    public:
      /// <summary>
      /// Calculates the integral part of a number.
      /// </summary>
      static Expr<double> Truncate(Expr<double> d)
  		{
	  		return Expr<double>(gcnew MethodInvokeExpression<double>
          (_Truncate_Expr_double_, nullptr, gcnew array<GenericExpression^>{d}));
      }

    };
    

    /// <summary>
    /// Class that represents variable of type unsigned char.
    /// </summary>
    template<> public ref class Var<unsigned char> : ExpressionWrapper<unsigned char>
    {
		public:
			Var<unsigned char>(String^ name)
			{
				_value = gcnew Variable<unsigned char>(name);
			}
			operator Expression<unsigned char>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type signed char.
    /// </summary>
    template<> public ref class Var<signed char> : ExpressionWrapper<signed char>
    {
		public:
			Var<signed char>(String^ name)
			{
				_value = gcnew Variable<signed char>(name);
			}
			operator Expression<signed char>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type float.
    /// </summary>
    template<> public ref class Var<float> : ExpressionWrapper<float>
    {
		public:
			Var<float>(String^ name)
			{
				_value = gcnew Variable<float>(name);
			}
			operator Expression<float>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type double.
    /// </summary>
    template<> public ref class Var<double> : ExpressionWrapper<double>
    {
		public:
			Var<double>(String^ name)
			{
				_value = gcnew Variable<double>(name);
			}
			operator Expression<double>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type System::Decimal.
    /// </summary>
    template<> public ref class Var<System::Decimal> : ExpressionWrapper<System::Decimal>
    {
		public:
			Var<System::Decimal>(String^ name)
			{
				_value = gcnew Variable<System::Decimal>(name);
			}
			operator Expression<System::Decimal>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type long long int (Int64).
    /// </summary>
    template<> public ref class Var<long long int> : ExpressionWrapper<long long int>
    {
		public:
			Var<long long int>(String^ name)
			{
				_value = gcnew Variable<long long int>(name);
			}
			operator Expression<long long int>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type short (Int16).
    /// </summary>
    template<> public ref class Var<short> : ExpressionWrapper<short>
    {
		public:
			Var<short>(String^ name)
			{
				_value = gcnew Variable<short>(name);
			}
			operator Expression<short>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type int (Int32).
    /// </summary>
    template<> public ref class Var<int> : ExpressionWrapper<int>
    {
		public:
			Var<int>(String^ name)
			{
				_value = gcnew Variable<int>(name);
			}
			operator Expression<int>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type unsigned long long int (UInt64).
    /// </summary>
    template<> public ref class Var<unsigned long long int> : ExpressionWrapper<unsigned long long int>
    {
		public:
			Var<unsigned long long int>(String^ name)
			{
				_value = gcnew Variable<unsigned long long int>(name);
			}
			operator Expression<unsigned long long int>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type unsigned short (UInt16).
    /// </summary>
    template<> public ref class Var<unsigned short> : ExpressionWrapper<unsigned short>
    {
		public:
			Var<unsigned short>(String^ name)
			{
				_value = gcnew Variable<unsigned short>(name);
			}
			operator Expression<unsigned short>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type unsigned int (UInt32).
    /// </summary>
    template<> public ref class Var<unsigned int> : ExpressionWrapper<unsigned int>
    {
		public:
			Var<unsigned int>(String^ name)
			{
				_value = gcnew Variable<unsigned int>(name);
			}
			operator Expression<unsigned int>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type bool.
    /// </summary>
    template<> public ref class Var<bool> : ExpressionWrapper<bool>
    {
		public:
			Var<bool>(String^ name)
			{
				_value = gcnew Variable<bool>(name);
			}
			operator Expression<bool>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type unicode wchar_t (Char).
    /// </summary>
    template<> public ref class Var<wchar_t> : ExpressionWrapper<wchar_t>
    {
		public:
			Var<wchar_t>(String^ name)
			{
				_value = gcnew Variable<wchar_t>(name);
			}
			operator Expression<wchar_t>^()
			{
				return _value;
			}
		};    

    /// <summary>
    /// Class that represents variable of type System::String.
    /// </summary>
    template<> public ref class Var<String^> : ExpressionWrapper<String^>
    {
		public:
			Var<String^>(String^ name)
			{
				_value = gcnew Variable<String^>(name);
			}
			operator Expression<String^>^()
			{
				return _value;
			}
		};    

  } 
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Microsoft Public License (Ms-PL)

Share

About the Author

Tomas Petricek

Czech Republic Czech Republic
I live in Prague, the capital city of Czech republic (most of the time Smile | :) ). I've been very interested in functional programming recently and I have a passion for the new Microsoft F# language. I'm writing a book about Functional Programming in the Real World that shows the ideas using examples in C# 3.0 and F#.
 
I've been Microsoft MVP (for C#) since 2004 and I'm one of the most active members of the F# community. I'm a computer science student at Charles University of Prague. My hobbies include photography, fractals and of course many things related to computers (except fixing them). My favorite book writers are Terry Pratchett and Philip K Dick and I like paintings by M. C. Escher.
 
PS: My favorite codeproject icon is Sheep | [baah] .

| Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.141223.1 | Last Updated 27 Jul 2007
Article Copyright 2007 by Tomas Petricek
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid