// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
// Generated from PrimitiveDataFrameColumn.BinaryOperators.tt. Do not modify directly
 
using System;
using System.Collections.Generic;
using System.Text;
 
namespace Microsoft.Data.Analysis
{
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(ByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(ByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(ByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(ByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(ByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(ByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(SingleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(Int32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(Int32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(Int32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(Int32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(Int64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(Int64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(Int64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(SByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(SByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(SByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(SByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(SByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(Int16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(Int16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(Int16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(Int16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(Int16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator +(UInt32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(UInt32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(UInt32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(UInt32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(UInt32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(UInt32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(UInt32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(UInt32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(UInt32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(UInt32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(UInt32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator +(UInt64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(UInt64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(UInt64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(UInt64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(UInt64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(UInt64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(UInt64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(UInt64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(UInt64DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(UInt64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(UInt16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(UInt16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(UInt16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(UInt16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(UInt16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(UInt16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Add(right);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(byte left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(ByteDataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(ByteDataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(ByteDataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(int left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(ByteDataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(long left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(sbyte left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(short left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt32DataFrameColumn operator +(ByteDataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(uint left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt64DataFrameColumn operator +(ByteDataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(ulong left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(ByteDataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ushort left, ByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(byte left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(int left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(long left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(sbyte left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(short left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(uint left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(ulong left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(DecimalDataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(ushort left, DecimalDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(byte left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(float left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(int left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(long left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(sbyte left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(short left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(uint left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(ulong left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(DoubleDataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(ushort left, DoubleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(byte left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(SingleDataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(int left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(long left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(sbyte left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(short left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(uint left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(ulong left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SingleDataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(ushort left, SingleDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(byte left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(Int32DataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(Int32DataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(Int32DataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(int left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int32DataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(long left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(sbyte left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(short left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int32DataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(uint left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(Int32DataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(ulong left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(Int32DataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ushort left, Int32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(byte left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(Int64DataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(Int64DataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(Int64DataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(int left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(long left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(sbyte left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(short left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(uint left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int64DataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(ushort left, Int64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(byte left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(SByteDataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(SByteDataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SByteDataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(int left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(SByteDataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(long left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(sbyte left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(short left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(SByteDataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(uint left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(SByteDataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(ulong left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(SByteDataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ushort left, SByteDataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(byte left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(Int16DataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(Int16DataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(Int16DataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(int left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int16DataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(long left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(sbyte left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(short left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(Int16DataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(uint left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(Int16DataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(ulong left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(Int16DataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ushort left, Int16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator +(UInt32DataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(byte left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(UInt32DataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(UInt32DataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(UInt32DataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(UInt32DataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(int left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(UInt32DataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(long left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(UInt32DataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(sbyte left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(UInt32DataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(short left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt32DataFrameColumn operator +(UInt32DataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(uint left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt64DataFrameColumn operator +(UInt32DataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(ulong left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt32DataFrameColumn operator +(UInt32DataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(ushort left, UInt32DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator +(UInt64DataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(byte left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(UInt64DataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(UInt64DataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(UInt64DataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(UInt64DataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(int left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(UInt64DataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(sbyte left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(UInt64DataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(short left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt64DataFrameColumn operator +(UInt64DataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(uint left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt64DataFrameColumn operator +(UInt64DataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(ulong left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt64DataFrameColumn operator +(UInt64DataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(ushort left, UInt64DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, byte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(byte left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DecimalDataFrameColumn operator +(UInt16DataFrameColumn left, decimal right)
        {
            return left.Add(right);
        }
        public static DecimalDataFrameColumn operator +(decimal left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static DoubleDataFrameColumn operator +(UInt16DataFrameColumn left, double right)
        {
            return left.Add(right);
        }
        public static DoubleDataFrameColumn operator +(double left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static SingleDataFrameColumn operator +(UInt16DataFrameColumn left, float right)
        {
            return left.Add(right);
        }
        public static SingleDataFrameColumn operator +(float left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, int right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(int left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int64DataFrameColumn operator +(UInt16DataFrameColumn left, long right)
        {
            return left.Add(right);
        }
        public static Int64DataFrameColumn operator +(long left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, sbyte right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(sbyte left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, short right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(short left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt32DataFrameColumn operator +(UInt16DataFrameColumn left, uint right)
        {
            return left.Add(right);
        }
        public static UInt32DataFrameColumn operator +(uint left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static UInt64DataFrameColumn operator +(UInt16DataFrameColumn left, ulong right)
        {
            return left.Add(right);
        }
        public static UInt64DataFrameColumn operator +(ulong left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
        public static Int32DataFrameColumn operator +(UInt16DataFrameColumn left, ushort right)
        {
            return left.Add(right);
        }
        public static Int32DataFrameColumn operator +(ushort left, UInt16DataFrameColumn right)
        {
            return right.ReverseAdd(left);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(ByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(ByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(ByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(ByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(ByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(ByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(SingleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(Int32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(Int32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(Int32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(Int32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(Int64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(Int64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(Int64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(SByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(SByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(SByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(SByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(SByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(Int16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(Int16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(Int16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(Int16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(Int16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator -(UInt32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(UInt32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(UInt32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(UInt32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(UInt32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(UInt32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(UInt32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(UInt32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(UInt32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(UInt32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(UInt32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator -(UInt64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(UInt64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(UInt64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(UInt64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(UInt64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(UInt64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(UInt64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(UInt64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(UInt64DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(UInt64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(UInt16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(UInt16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(UInt16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(UInt16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(UInt16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(UInt16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Subtract(right);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(byte left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(ByteDataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(ByteDataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(ByteDataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(int left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(ByteDataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(long left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(sbyte left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(short left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt32DataFrameColumn operator -(ByteDataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(uint left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt64DataFrameColumn operator -(ByteDataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(ulong left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(ByteDataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ushort left, ByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(byte left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(int left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(long left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(sbyte left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(short left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(uint left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(ulong left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(DecimalDataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(ushort left, DecimalDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(byte left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(float left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(int left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(long left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(sbyte left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(short left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(uint left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(ulong left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(DoubleDataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(ushort left, DoubleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(byte left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(SingleDataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(int left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(long left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(sbyte left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(short left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(uint left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(ulong left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SingleDataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(ushort left, SingleDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(byte left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(Int32DataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(Int32DataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(Int32DataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(int left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int32DataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(long left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(sbyte left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(short left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int32DataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(uint left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(Int32DataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(ulong left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(Int32DataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ushort left, Int32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(byte left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(Int64DataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(Int64DataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(Int64DataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(int left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(long left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(sbyte left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(short left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(uint left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int64DataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(ushort left, Int64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(byte left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(SByteDataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(SByteDataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SByteDataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(int left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(SByteDataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(long left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(sbyte left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(short left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(SByteDataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(uint left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(SByteDataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(ulong left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(SByteDataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ushort left, SByteDataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(byte left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(Int16DataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(Int16DataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(Int16DataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(int left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int16DataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(long left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(sbyte left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(short left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(Int16DataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(uint left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(Int16DataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(ulong left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(Int16DataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ushort left, Int16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator -(UInt32DataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(byte left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(UInt32DataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(UInt32DataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(UInt32DataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(UInt32DataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(int left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(UInt32DataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(long left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(UInt32DataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(sbyte left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(UInt32DataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(short left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt32DataFrameColumn operator -(UInt32DataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(uint left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt64DataFrameColumn operator -(UInt32DataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(ulong left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt32DataFrameColumn operator -(UInt32DataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(ushort left, UInt32DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator -(UInt64DataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(byte left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(UInt64DataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(UInt64DataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(UInt64DataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(UInt64DataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(int left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(UInt64DataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(sbyte left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(UInt64DataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(short left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt64DataFrameColumn operator -(UInt64DataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(uint left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt64DataFrameColumn operator -(UInt64DataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(ulong left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt64DataFrameColumn operator -(UInt64DataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(ushort left, UInt64DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, byte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(byte left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DecimalDataFrameColumn operator -(UInt16DataFrameColumn left, decimal right)
        {
            return left.Subtract(right);
        }
        public static DecimalDataFrameColumn operator -(decimal left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static DoubleDataFrameColumn operator -(UInt16DataFrameColumn left, double right)
        {
            return left.Subtract(right);
        }
        public static DoubleDataFrameColumn operator -(double left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static SingleDataFrameColumn operator -(UInt16DataFrameColumn left, float right)
        {
            return left.Subtract(right);
        }
        public static SingleDataFrameColumn operator -(float left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, int right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(int left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int64DataFrameColumn operator -(UInt16DataFrameColumn left, long right)
        {
            return left.Subtract(right);
        }
        public static Int64DataFrameColumn operator -(long left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, sbyte right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(sbyte left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, short right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(short left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt32DataFrameColumn operator -(UInt16DataFrameColumn left, uint right)
        {
            return left.Subtract(right);
        }
        public static UInt32DataFrameColumn operator -(uint left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static UInt64DataFrameColumn operator -(UInt16DataFrameColumn left, ulong right)
        {
            return left.Subtract(right);
        }
        public static UInt64DataFrameColumn operator -(ulong left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
        public static Int32DataFrameColumn operator -(UInt16DataFrameColumn left, ushort right)
        {
            return left.Subtract(right);
        }
        public static Int32DataFrameColumn operator -(ushort left, UInt16DataFrameColumn right)
        {
            return right.ReverseSubtract(left);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(ByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(ByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(ByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(ByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(ByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(ByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(SingleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(Int32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(Int32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(Int32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(Int32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(Int64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(Int64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(Int64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(SByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(SByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(SByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(SByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(SByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(Int16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(Int16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(Int16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(Int16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(Int16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator *(UInt32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(UInt32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(UInt32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(UInt32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(UInt32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(UInt32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(UInt32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(UInt32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(UInt32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(UInt32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(UInt32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator *(UInt64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(UInt64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(UInt64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(UInt64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(UInt64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(UInt64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(UInt64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(UInt64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(UInt64DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(UInt64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(UInt16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(UInt16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(UInt16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(UInt16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(UInt16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(UInt16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Multiply(right);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(byte left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(ByteDataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(ByteDataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(ByteDataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(int left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(ByteDataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(long left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(sbyte left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(short left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt32DataFrameColumn operator *(ByteDataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(uint left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt64DataFrameColumn operator *(ByteDataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(ulong left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(ByteDataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ushort left, ByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(byte left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(int left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(long left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(sbyte left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(short left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(uint left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(ulong left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(DecimalDataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(ushort left, DecimalDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(byte left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(float left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(int left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(long left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(sbyte left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(short left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(uint left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(ulong left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(DoubleDataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(ushort left, DoubleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(byte left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(SingleDataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(int left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(long left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(sbyte left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(short left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(uint left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(ulong left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SingleDataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(ushort left, SingleDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(byte left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(Int32DataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(Int32DataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(Int32DataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(int left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int32DataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(long left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(sbyte left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(short left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int32DataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(uint left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(Int32DataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(ulong left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(Int32DataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ushort left, Int32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(byte left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(Int64DataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(Int64DataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(Int64DataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(int left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(long left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(sbyte left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(short left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(uint left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int64DataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(ushort left, Int64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(byte left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(SByteDataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(SByteDataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SByteDataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(int left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(SByteDataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(long left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(sbyte left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(short left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(SByteDataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(uint left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(SByteDataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(ulong left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(SByteDataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ushort left, SByteDataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(byte left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(Int16DataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(Int16DataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(Int16DataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(int left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int16DataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(long left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(sbyte left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(short left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(Int16DataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(uint left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(Int16DataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(ulong left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(Int16DataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ushort left, Int16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator *(UInt32DataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(byte left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(UInt32DataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(UInt32DataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(UInt32DataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(UInt32DataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(int left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(UInt32DataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(long left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(UInt32DataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(sbyte left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(UInt32DataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(short left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt32DataFrameColumn operator *(UInt32DataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(uint left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt64DataFrameColumn operator *(UInt32DataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(ulong left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt32DataFrameColumn operator *(UInt32DataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(ushort left, UInt32DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator *(UInt64DataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(byte left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(UInt64DataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(UInt64DataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(UInt64DataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(UInt64DataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(int left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(UInt64DataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(sbyte left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(UInt64DataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(short left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt64DataFrameColumn operator *(UInt64DataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(uint left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt64DataFrameColumn operator *(UInt64DataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(ulong left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt64DataFrameColumn operator *(UInt64DataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(ushort left, UInt64DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, byte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(byte left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DecimalDataFrameColumn operator *(UInt16DataFrameColumn left, decimal right)
        {
            return left.Multiply(right);
        }
        public static DecimalDataFrameColumn operator *(decimal left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static DoubleDataFrameColumn operator *(UInt16DataFrameColumn left, double right)
        {
            return left.Multiply(right);
        }
        public static DoubleDataFrameColumn operator *(double left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static SingleDataFrameColumn operator *(UInt16DataFrameColumn left, float right)
        {
            return left.Multiply(right);
        }
        public static SingleDataFrameColumn operator *(float left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, int right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(int left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int64DataFrameColumn operator *(UInt16DataFrameColumn left, long right)
        {
            return left.Multiply(right);
        }
        public static Int64DataFrameColumn operator *(long left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, sbyte right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(sbyte left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, short right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(short left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt32DataFrameColumn operator *(UInt16DataFrameColumn left, uint right)
        {
            return left.Multiply(right);
        }
        public static UInt32DataFrameColumn operator *(uint left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static UInt64DataFrameColumn operator *(UInt16DataFrameColumn left, ulong right)
        {
            return left.Multiply(right);
        }
        public static UInt64DataFrameColumn operator *(ulong left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
        public static Int32DataFrameColumn operator *(UInt16DataFrameColumn left, ushort right)
        {
            return left.Multiply(right);
        }
        public static Int32DataFrameColumn operator *(ushort left, UInt16DataFrameColumn right)
        {
            return right.ReverseMultiply(left);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(ByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(ByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(ByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(ByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(ByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(ByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(SingleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(Int32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(Int32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(Int32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(Int32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(Int64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(Int64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(Int64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(SByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(SByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(SByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(SByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(SByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(Int16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(Int16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(Int16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(Int16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(Int16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator /(UInt32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(UInt32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(UInt32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(UInt32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(UInt32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(UInt32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(UInt32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(UInt32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(UInt32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(UInt32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(UInt32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator /(UInt64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(UInt64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(UInt64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(UInt64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(UInt64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(UInt64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(UInt64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(UInt64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(UInt64DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(UInt64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(UInt16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(UInt16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(UInt16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(UInt16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(UInt16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(UInt16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Divide(right);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(byte left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(ByteDataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(ByteDataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(ByteDataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(int left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(ByteDataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(long left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(sbyte left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(short left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt32DataFrameColumn operator /(ByteDataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(uint left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt64DataFrameColumn operator /(ByteDataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(ulong left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(ByteDataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ushort left, ByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(byte left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(int left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(long left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(sbyte left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(short left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(uint left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(ulong left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(DecimalDataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(ushort left, DecimalDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(byte left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(float left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(int left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(long left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(sbyte left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(short left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(uint left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(ulong left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(DoubleDataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(ushort left, DoubleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(byte left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(SingleDataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(int left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(long left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(sbyte left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(short left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(uint left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(ulong left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SingleDataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(ushort left, SingleDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(byte left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(Int32DataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(Int32DataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(Int32DataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(int left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int32DataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(long left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(sbyte left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(short left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int32DataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(uint left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(Int32DataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(ulong left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(Int32DataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ushort left, Int32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(byte left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(Int64DataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(Int64DataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(Int64DataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(int left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(long left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(sbyte left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(short left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(uint left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int64DataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(ushort left, Int64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(byte left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(SByteDataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(SByteDataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SByteDataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(int left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(SByteDataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(long left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(sbyte left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(short left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(SByteDataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(uint left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(SByteDataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(ulong left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(SByteDataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ushort left, SByteDataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(byte left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(Int16DataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(Int16DataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(Int16DataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(int left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int16DataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(long left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(sbyte left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(short left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(Int16DataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(uint left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(Int16DataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(ulong left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(Int16DataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ushort left, Int16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator /(UInt32DataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(byte left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(UInt32DataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(UInt32DataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(UInt32DataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(UInt32DataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(int left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(UInt32DataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(long left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(UInt32DataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(sbyte left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(UInt32DataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(short left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt32DataFrameColumn operator /(UInt32DataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(uint left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt64DataFrameColumn operator /(UInt32DataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(ulong left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt32DataFrameColumn operator /(UInt32DataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(ushort left, UInt32DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator /(UInt64DataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(byte left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(UInt64DataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(UInt64DataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(UInt64DataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(UInt64DataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(int left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(UInt64DataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(sbyte left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(UInt64DataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(short left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt64DataFrameColumn operator /(UInt64DataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(uint left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt64DataFrameColumn operator /(UInt64DataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(ulong left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt64DataFrameColumn operator /(UInt64DataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(ushort left, UInt64DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, byte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(byte left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DecimalDataFrameColumn operator /(UInt16DataFrameColumn left, decimal right)
        {
            return left.Divide(right);
        }
        public static DecimalDataFrameColumn operator /(decimal left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static DoubleDataFrameColumn operator /(UInt16DataFrameColumn left, double right)
        {
            return left.Divide(right);
        }
        public static DoubleDataFrameColumn operator /(double left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static SingleDataFrameColumn operator /(UInt16DataFrameColumn left, float right)
        {
            return left.Divide(right);
        }
        public static SingleDataFrameColumn operator /(float left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, int right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(int left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int64DataFrameColumn operator /(UInt16DataFrameColumn left, long right)
        {
            return left.Divide(right);
        }
        public static Int64DataFrameColumn operator /(long left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, sbyte right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(sbyte left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, short right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(short left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt32DataFrameColumn operator /(UInt16DataFrameColumn left, uint right)
        {
            return left.Divide(right);
        }
        public static UInt32DataFrameColumn operator /(uint left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static UInt64DataFrameColumn operator /(UInt16DataFrameColumn left, ulong right)
        {
            return left.Divide(right);
        }
        public static UInt64DataFrameColumn operator /(ulong left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
        public static Int32DataFrameColumn operator /(UInt16DataFrameColumn left, ushort right)
        {
            return left.Divide(right);
        }
        public static Int32DataFrameColumn operator /(ushort left, UInt16DataFrameColumn right)
        {
            return right.ReverseDivide(left);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(ByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(ByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(ByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(ByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(ByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(ByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(SingleDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(Int32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(Int32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(Int32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(Int32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(Int64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(Int64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(Int64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(SByteDataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(SByteDataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SByteDataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(SByteDataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(SByteDataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(SByteDataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(Int16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(Int16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(Int16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(Int16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(Int16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator %(UInt32DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(UInt32DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(UInt32DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(UInt32DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(UInt32DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(UInt32DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(UInt32DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(UInt32DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(UInt32DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(UInt32DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(UInt32DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator %(UInt64DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(UInt64DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(UInt64DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(UInt64DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(UInt64DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(UInt64DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(UInt64DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(UInt64DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(UInt64DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(UInt64DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, ByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(UInt16DataFrameColumn left, DecimalDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(UInt16DataFrameColumn left, DoubleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(UInt16DataFrameColumn left, SingleDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, Int32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(UInt16DataFrameColumn left, Int64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, SByteDataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, Int16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(UInt16DataFrameColumn left, UInt32DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(UInt16DataFrameColumn left, UInt64DataFrameColumn right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, UInt16DataFrameColumn right)
        {
            return left.Modulo(right);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(byte left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(ByteDataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(ByteDataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(ByteDataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(int left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(ByteDataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(long left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(sbyte left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(short left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt32DataFrameColumn operator %(ByteDataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(uint left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt64DataFrameColumn operator %(ByteDataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(ulong left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(ByteDataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ushort left, ByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class DecimalDataFrameColumn
    {
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(byte left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(int left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(long left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(sbyte left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(short left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(uint left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(ulong left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(DecimalDataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(ushort left, DecimalDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class DoubleDataFrameColumn
    {
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(byte left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(float left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(int left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(long left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(sbyte left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(short left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(uint left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(ulong left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(DoubleDataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(ushort left, DoubleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class SingleDataFrameColumn
    {
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(byte left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(SingleDataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(int left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(long left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(sbyte left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(short left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(uint left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(ulong left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SingleDataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(ushort left, SingleDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(byte left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(Int32DataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(Int32DataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(Int32DataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(int left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int32DataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(long left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(sbyte left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(short left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int32DataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(uint left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(Int32DataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(ulong left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(Int32DataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ushort left, Int32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(byte left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(Int64DataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(Int64DataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(Int64DataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(int left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(long left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(sbyte left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(short left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(uint left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int64DataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(ushort left, Int64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(byte left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(SByteDataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(SByteDataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SByteDataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(int left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(SByteDataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(long left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(sbyte left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(short left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(SByteDataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(uint left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(SByteDataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(ulong left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(SByteDataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ushort left, SByteDataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(byte left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(Int16DataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(Int16DataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(Int16DataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(int left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int16DataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(long left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(sbyte left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(short left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(Int16DataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(uint left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(Int16DataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(ulong left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(Int16DataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ushort left, Int16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator %(UInt32DataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(byte left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(UInt32DataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(UInt32DataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(UInt32DataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(UInt32DataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(int left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(UInt32DataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(long left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(UInt32DataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(sbyte left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(UInt32DataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(short left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt32DataFrameColumn operator %(UInt32DataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(uint left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt64DataFrameColumn operator %(UInt32DataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(ulong left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt32DataFrameColumn operator %(UInt32DataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(ushort left, UInt32DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator %(UInt64DataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(byte left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(UInt64DataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(UInt64DataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(UInt64DataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(UInt64DataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(int left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(UInt64DataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(sbyte left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(UInt64DataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(short left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt64DataFrameColumn operator %(UInt64DataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(uint left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt64DataFrameColumn operator %(UInt64DataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(ulong left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt64DataFrameColumn operator %(UInt64DataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(ushort left, UInt64DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, byte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(byte left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DecimalDataFrameColumn operator %(UInt16DataFrameColumn left, decimal right)
        {
            return left.Modulo(right);
        }
        public static DecimalDataFrameColumn operator %(decimal left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static DoubleDataFrameColumn operator %(UInt16DataFrameColumn left, double right)
        {
            return left.Modulo(right);
        }
        public static DoubleDataFrameColumn operator %(double left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static SingleDataFrameColumn operator %(UInt16DataFrameColumn left, float right)
        {
            return left.Modulo(right);
        }
        public static SingleDataFrameColumn operator %(float left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, int right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(int left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int64DataFrameColumn operator %(UInt16DataFrameColumn left, long right)
        {
            return left.Modulo(right);
        }
        public static Int64DataFrameColumn operator %(long left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, sbyte right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(sbyte left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, short right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(short left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt32DataFrameColumn operator %(UInt16DataFrameColumn left, uint right)
        {
            return left.Modulo(right);
        }
        public static UInt32DataFrameColumn operator %(uint left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static UInt64DataFrameColumn operator %(UInt16DataFrameColumn left, ulong right)
        {
            return left.Modulo(right);
        }
        public static UInt64DataFrameColumn operator %(ulong left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
        public static Int32DataFrameColumn operator %(UInt16DataFrameColumn left, ushort right)
        {
            return left.Modulo(right);
        }
        public static Int32DataFrameColumn operator %(ushort left, UInt16DataFrameColumn right)
        {
            return right.ReverseModulo(left);
        }
    }
    public partial class BooleanDataFrameColumn
    {
        public static BooleanDataFrameColumn operator &(BooleanDataFrameColumn left, BooleanDataFrameColumn right)
        {
            return left.And(right);
        }
    }
    public partial class BooleanDataFrameColumn
    {
        public static BooleanDataFrameColumn operator &(BooleanDataFrameColumn left, bool right)
        {
            return left.And(right);
        }
    }
    public partial class BooleanDataFrameColumn
    {
        public static BooleanDataFrameColumn operator |(BooleanDataFrameColumn left, BooleanDataFrameColumn right)
        {
            return left.Or(right);
        }
    }
    public partial class BooleanDataFrameColumn
    {
        public static BooleanDataFrameColumn operator |(BooleanDataFrameColumn left, bool right)
        {
            return left.Or(right);
        }
    }
    public partial class BooleanDataFrameColumn
    {
        public static BooleanDataFrameColumn operator ^(BooleanDataFrameColumn left, BooleanDataFrameColumn right)
        {
            return left.Xor(right);
        }
    }
    public partial class BooleanDataFrameColumn
    {
        public static BooleanDataFrameColumn operator ^(BooleanDataFrameColumn left, bool right)
        {
            return left.Xor(right);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator <<(ByteDataFrameColumn left, int value)
        {
            return left.LeftShift(value);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator <<(Int32DataFrameColumn left, int value)
        {
            return left.LeftShift(value);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator <<(Int64DataFrameColumn left, int value)
        {
            return left.LeftShift(value);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator <<(SByteDataFrameColumn left, int value)
        {
            return left.LeftShift(value);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator <<(Int16DataFrameColumn left, int value)
        {
            return left.LeftShift(value);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator <<(UInt32DataFrameColumn left, int value)
        {
            return left.LeftShift(value);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator <<(UInt64DataFrameColumn left, int value)
        {
            return left.LeftShift(value);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator <<(UInt16DataFrameColumn left, int value)
        {
            return left.LeftShift(value);
        }
    }
    public partial class ByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator >>(ByteDataFrameColumn left, int value)
        {
            return left.RightShift(value);
        }
    }
    public partial class Int32DataFrameColumn
    {
        public static Int32DataFrameColumn operator >>(Int32DataFrameColumn left, int value)
        {
            return left.RightShift(value);
        }
    }
    public partial class Int64DataFrameColumn
    {
        public static Int64DataFrameColumn operator >>(Int64DataFrameColumn left, int value)
        {
            return left.RightShift(value);
        }
    }
    public partial class SByteDataFrameColumn
    {
        public static Int32DataFrameColumn operator >>(SByteDataFrameColumn left, int value)
        {
            return left.RightShift(value);
        }
    }
    public partial class Int16DataFrameColumn
    {
        public static Int32DataFrameColumn operator >>(Int16DataFrameColumn left, int value)
        {
            return left.RightShift(value);
        }
    }
    public partial class UInt32DataFrameColumn
    {
        public static UInt32DataFrameColumn operator >>(UInt32DataFrameColumn left, int value)
        {
            return left.RightShift(value);
        }
    }
    public partial class UInt64DataFrameColumn
    {
        public static UInt64DataFrameColumn operator >>(UInt64DataFrameColumn left, int value)
        {
            return left.RightShift(value);
        }
    }
    public partial class UInt16DataFrameColumn
    {
        public static Int32DataFrameColumn operator >>(UInt16DataFrameColumn left, int value)
        {
            return left.RightShift(value);
        }
    }
}