// 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 DataFrameBinaryOperators.tt. Do not modify directly
 
using System;
using System.Collections.Generic;
 
namespace Microsoft.Data.Analysis
{
    public partial class DataFrame
    {
#pragma warning disable 1591
        public static DataFrame operator +(DataFrame df, byte value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(byte value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, decimal value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(decimal value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, double value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(double value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, float value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(float value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, int value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(int value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, long value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(long value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, sbyte value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(sbyte value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, short value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(short value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, uint value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(uint value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, ulong value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(ulong value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator +(DataFrame df, ushort value)
        {
            return df.Add(value);
        }
 
        public static DataFrame operator +(ushort value, DataFrame df)
        {
            return df.ReverseAdd(value);
        }
 
        public static DataFrame operator -(DataFrame df, byte value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(byte value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, decimal value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(decimal value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, double value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(double value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, float value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(float value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, int value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(int value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, long value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(long value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, sbyte value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(sbyte value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, short value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(short value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, uint value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(uint value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, ulong value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(ulong value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator -(DataFrame df, ushort value)
        {
            return df.Subtract(value);
        }
 
        public static DataFrame operator -(ushort value, DataFrame df)
        {
            return df.ReverseSubtract(value);
        }
 
        public static DataFrame operator *(DataFrame df, byte value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(byte value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, decimal value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(decimal value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, double value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(double value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, float value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(float value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, int value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(int value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, long value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(long value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, sbyte value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(sbyte value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, short value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(short value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, uint value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(uint value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, ulong value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(ulong value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator *(DataFrame df, ushort value)
        {
            return df.Multiply(value);
        }
 
        public static DataFrame operator *(ushort value, DataFrame df)
        {
            return df.ReverseMultiply(value);
        }
 
        public static DataFrame operator /(DataFrame df, byte value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(byte value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, decimal value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(decimal value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, double value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(double value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, float value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(float value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, int value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(int value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, long value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(long value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, sbyte value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(sbyte value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, short value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(short value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, uint value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(uint value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, ulong value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(ulong value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator /(DataFrame df, ushort value)
        {
            return df.Divide(value);
        }
 
        public static DataFrame operator /(ushort value, DataFrame df)
        {
            return df.ReverseDivide(value);
        }
 
        public static DataFrame operator %(DataFrame df, byte value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(byte value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, decimal value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(decimal value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, double value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(double value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, float value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(float value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, int value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(int value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, long value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(long value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, sbyte value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(sbyte value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, short value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(short value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, uint value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(uint value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, ulong value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(ulong value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator %(DataFrame df, ushort value)
        {
            return df.Modulo(value);
        }
 
        public static DataFrame operator %(ushort value, DataFrame df)
        {
            return df.ReverseModulo(value);
        }
 
        public static DataFrame operator <<(DataFrame df, int value)
        {
            return df.LeftShift(value);
        }
 
        public static DataFrame operator >>(DataFrame df, int value)
        {
            return df.RightShift(value);
        }
 
    }
}