Module: CNTK

Defined in:: lib/cntk.rb,
lib/cntk/io.rb,
lib/cntk/ops.rb,
lib/cntk/axis.rb,
lib/cntk/value.rb,
lib/cntk/layers.rb,
lib/cntk/ndmask.rb,
lib/cntk/inspect.rb,
lib/cntk/learner.rb,
lib/cntk/ndshape.rb,
lib/cntk/trainer.rb,
lib/cntk/function.rb,
lib/cntk/variable.rb,
lib/cntk/dictionary.rb,
lib/cntk/initializer.rb,
lib/cntk/ndarrayview.rb,
ext/cntk/cntk_wrap.cxx

Defined Under Namespace

Modules: Initializer, InspectUtil, Layers, Ops, VariableExtend Classes: AdditionalLearningOptions, Axis, BackPropState, ConstIterator, Constant, DeviceDescriptor, Dictionary, DictionaryValue, DistributedCommunicator, DistributedLearner, DistributedWorkerDescriptor, Function, GC_VALUE, Iterator, Learner, MinibatchData, MinibatchInfo, MinibatchSource, MinibatchTable, MomentumAsTimeConstantSchedule, MomentumSchedule, NDArrayView, NDMask, NDShape, Parameter, QuantizedDistributedCommunicator, StdUMapStreamInfoMinibatchData, StdUMapVariableValue, StdUSetDistributedWorkerDescriptor, StdUSetVariable, StdVectorDictionaryValue, StdVectorPairVariableVariable, StreamInformation, Trainer, TrainingParameterPerMinibatchSchedule, TrainingParameterPerSampleSchedule, TrainingSession, Value, Variable

Constant Summary collapse

SHARED_PTR_DISOWN =

SWIG_From_int(static_cast< int >(0))

DataType_Unknown =

SWIG_From_int(static_cast< int >(CNTK::DataType::Unknown))

DataType_Float =

SWIG_From_int(static_cast< int >(CNTK::DataType::Float))

DataType_Double =

SWIG_From_int(static_cast< int >(CNTK::DataType::Double))

StorageFormat_Dense =

SWIG_From_int(static_cast< int >(CNTK::StorageFormat::Dense))

StorageFormat_SparseCSC =

SWIG_From_int(static_cast< int >(CNTK::StorageFormat::SparseCSC))

StorageFormat_SparseBlockCol =

SWIG_From_int(static_cast< int >(CNTK::StorageFormat::SparseBlockCol))

DeviceKind_CPU =

SWIG_From_int(static_cast< int >(CNTK::DeviceKind::CPU))

DeviceKind_GPU =

SWIG_From_int(static_cast< int >(CNTK::DeviceKind::GPU))

MaskKind_Invalid =

SWIG_From_int(static_cast< int >(CNTK::MaskKind::Invalid))

MaskKind_Valid =

SWIG_From_int(static_cast< int >(CNTK::MaskKind::Valid))

MaskKind_SequenceBegin =

SWIG_From_int(static_cast< int >(CNTK::MaskKind::SequenceBegin))

VariableKind_Input =

SWIG_From_int(static_cast< int >(CNTK::VariableKind::Input))

VariableKind_Output =

SWIG_From_int(static_cast< int >(CNTK::VariableKind::Output))

VariableKind_Parameter =

SWIG_From_int(static_cast< int >(CNTK::VariableKind::Parameter))

VariableKind_Constant =

SWIG_From_int(static_cast< int >(CNTK::VariableKind::Constant))

VariableKind_Placeholder =

SWIG_From_int(static_cast< int >(CNTK::VariableKind::Placeholder))

ParameterCloningMethod_Share =

SWIG_From_int(static_cast< int >(CNTK::ParameterCloningMethod::Share))

ParameterCloningMethod_Clone =

SWIG_From_int(static_cast< int >(CNTK::ParameterCloningMethod::Clone))

ParameterCloningMethod_Freeze =

SWIG_From_int(static_cast< int >(CNTK::ParameterCloningMethod::Freeze))

PoolingType_Max =

SWIG_From_int(static_cast< int >(CNTK::PoolingType::Max))

PoolingType_Average =

SWIG_From_int(static_cast< int >(CNTK::PoolingType::Average))

Class Method Summary collapse

Class Method Details

.__adam_learner__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 57208

SWIGINTERN VALUE _wrap___adam_learner__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs;
  if (argc > 6) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___adam_learner____SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___adam_learner____SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___adam_learner____SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CNTK__AdditionalLearningOptions, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap___adam_learner____SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "__adam_learner__", 
    "    CNTK::LearnerPtr __adam_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule, bool unitGain, CNTK::MomentumSchedule const &varianceMomentumSchedule, CNTK::AdditionalLearningOptions additionalOptions)\n"
    "    CNTK::LearnerPtr __adam_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule, bool unitGain, CNTK::MomentumSchedule const &varianceMomentumSchedule)\n"
    "    CNTK::LearnerPtr __adam_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule, bool unitGain)\n"
    "    CNTK::LearnerPtr __adam_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule)\n");
  
  return Qnil;
}

.alias(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 52036

SWIGINTERN VALUE _wrap___alias__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___alias____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___alias____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__alias__", 
    "    CNTK::FunctionPtr __alias__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __alias__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__as_block__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 52245

SWIGINTERN VALUE _wrap___as_block__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___as_block____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___as_block____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__as_block__", 
    "    CNTK::FunctionPtr __as_block__(CNTK::FunctionPtr &&composite, std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > const &argumentsMap, std::wstring const &blockOpName, std::wstring const &blockName)\n"
    "    CNTK::FunctionPtr __as_block__(CNTK::FunctionPtr &&composite, std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > const &argumentsMap, std::wstring const &blockOpName)\n");
  
  return Qnil;
}

.__batch_normalization__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 50292

SWIGINTERN VALUE _wrap___batch_normalization__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[12];
  int ii;
  
  argc = nargs;
  if (argc > 12) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap___batch_normalization____SWIG_5(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap___batch_normalization____SWIG_4(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap___batch_normalization____SWIG_3(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap___batch_normalization____SWIG_2(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap___batch_normalization____SWIG_1(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_double(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_wstring(argv[11], (std::wstring**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap___batch_normalization____SWIG_0(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 12, "__batch_normalization__", 
    "    CNTK::FunctionPtr __batch_normalization__(CNTK::Variable const &operand, CNTK::Variable const &scale, CNTK::Variable const &bias, CNTK::Variable const &runningMean, CNTK::Variable const &runningInvStd, CNTK::Variable const &runningSampleCount, bool spatial, double normalizationTimeConstant, double blendTimeConstant, double epsilon, bool useCuDNNEngine, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __batch_normalization__(CNTK::Variable const &operand, CNTK::Variable const &scale, CNTK::Variable const &bias, CNTK::Variable const &runningMean, CNTK::Variable const &runningInvStd, CNTK::Variable const &runningSampleCount, bool spatial, double normalizationTimeConstant, double blendTimeConstant, double epsilon, bool useCuDNNEngine)\n"
    "    CNTK::FunctionPtr __batch_normalization__(CNTK::Variable const &operand, CNTK::Variable const &scale, CNTK::Variable const &bias, CNTK::Variable const &runningMean, CNTK::Variable const &runningInvStd, CNTK::Variable const &runningSampleCount, bool spatial, double normalizationTimeConstant, double blendTimeConstant, double epsilon)\n"
    "    CNTK::FunctionPtr __batch_normalization__(CNTK::Variable const &operand, CNTK::Variable const &scale, CNTK::Variable const &bias, CNTK::Variable const &runningMean, CNTK::Variable const &runningInvStd, CNTK::Variable const &runningSampleCount, bool spatial, double normalizationTimeConstant, double blendTimeConstant)\n"
    "    CNTK::FunctionPtr __batch_normalization__(CNTK::Variable const &operand, CNTK::Variable const &scale, CNTK::Variable const &bias, CNTK::Variable const &runningMean, CNTK::Variable const &runningInvStd, CNTK::Variable const &runningSampleCount, bool spatial, double normalizationTimeConstant)\n"
    "    CNTK::FunctionPtr __batch_normalization__(CNTK::Variable const &operand, CNTK::Variable const &scale, CNTK::Variable const &bias, CNTK::Variable const &runningMean, CNTK::Variable const &runningInvStd, CNTK::Variable const &runningSampleCount, bool spatial)\n");
  
  return Qnil;
}

.__bilinear_initializer__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 27741

SWIGINTERN VALUE
_wrap___bilinear_initializer__(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  CNTK::Dictionary result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","CNTK::BilinearInitializer", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","CNTK::BilinearInitializer", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    try {
      result = CNTK::BilinearInitializer(arg1,arg2); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_NewPointerObj((new CNTK::Dictionary(static_cast< const CNTK::Dictionary& >(result))), SWIGTYPE_p_CNTK__Dictionary, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.__binary_cross_entropy__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 41502

SWIGINTERN VALUE _wrap___binary_cross_entropy__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___binary_cross_entropy____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___binary_cross_entropy____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__binary_cross_entropy__", 
    "    CNTK::FunctionPtr __binary_cross_entropy__(CNTK::Variable const &prediction, CNTK::Variable const &targets, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __binary_cross_entropy__(CNTK::Variable const &prediction, CNTK::Variable const &targets)\n");
  
  return Qnil;
}

.__broadcast_as__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 53539

SWIGINTERN VALUE _wrap___broadcast_as__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___broadcast_as____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___broadcast_as____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__broadcast_as__", 
    "    CNTK::FunctionPtr __broadcast_as__(CNTK::Variable const &operand, CNTK::Variable const &broadcastAs, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __broadcast_as__(CNTK::Variable const &operand, CNTK::Variable const &broadcastAs)\n");
  
  return Qnil;
}

.ceil(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 36230

SWIGINTERN VALUE _wrap___ceil__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___ceil____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ceil____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__ceil__", 
    "    CNTK::FunctionPtr __ceil__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __ceil__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__classification_error__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 43102

SWIGINTERN VALUE _wrap___classification_error__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___classification_error____SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___classification_error____SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___classification_error____SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___classification_error____SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___classification_error____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_wstring(argv[4], (std::wstring**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___classification_error____SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__classification_error__", 
    "    CNTK::FunctionPtr __classification_error__(CNTK::Variable const &prediction, CNTK::Variable const &labels, size_t topN, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __classification_error__(CNTK::Variable const &prediction, CNTK::Variable const &labels, size_t topN, CNTK::Axis const &axis)\n"
    "    CNTK::FunctionPtr __classification_error__(CNTK::Variable const &prediction, CNTK::Variable const &labels, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __classification_error__(CNTK::Variable const &prediction, CNTK::Variable const &labels, CNTK::Axis const &axis)\n"
    "    CNTK::FunctionPtr __classification_error__(CNTK::Variable const &prediction, CNTK::Variable const &labels, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __classification_error__(CNTK::Variable const &prediction, CNTK::Variable const &labels)\n");
  
  return Qnil;
}

.clip(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 51312

SWIGINTERN VALUE _wrap___clip__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___clip____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___clip____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__clip__", 
    "    CNTK::FunctionPtr __clip__(CNTK::Variable const &operand, CNTK::Variable const &min, CNTK::Variable const &max, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __clip__(CNTK::Variable const &operand, CNTK::Variable const &min, CNTK::Variable const &max)\n");
  
  return Qnil;
}

.combine(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 51889

SWIGINTERN VALUE _wrap___combine__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Variable,std::allocator< CNTK::Variable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___combine____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Variable,std::allocator< CNTK::Variable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___combine____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__combine__", 
    "    CNTK::FunctionPtr __combine__(std::vector< CNTK::Variable,std::allocator< CNTK::Variable > > const &operands, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __combine__(std::vector< CNTK::Variable,std::allocator< CNTK::Variable > > const &operands)\n");
  
  return Qnil;
}

.__compute_input_per_dim_means_and_inv_std_devs__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 68166

SWIGINTERN VALUE _wrap___compute_input_per_dim_means_and_inv_std_devs__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_std__pairT_std__shared_ptrT_CNTK__NDArrayView_t_std__shared_ptrT_CNTK__NDArrayView_t_t_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_std__pairT_std__shared_ptrT_CNTK__NDArrayView_t_std__shared_ptrT_CNTK__NDArrayView_t_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___compute_input_per_dim_means_and_inv_std_devs____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__StreamInformation_std__pairT_std__shared_ptrT_CNTK__NDArrayView_t_std__shared_ptrT_CNTK__NDArrayView_t_t_std__hashT_CNTK__StreamInformation_t_std__equal_toT_CNTK__StreamInformation_t_std__allocatorT_std__pairT_CNTK__StreamInformation_const_std__pairT_std__shared_ptrT_CNTK__NDArrayView_t_std__shared_ptrT_CNTK__NDArrayView_t_t_t_t_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__DeviceDescriptor, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___compute_input_per_dim_means_and_inv_std_devs____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__compute_input_per_dim_means_and_inv_std_devs__", 
    "    void __compute_input_per_dim_means_and_inv_std_devs__(CNTK::MinibatchSourcePtr const &minibatchSource, std::unordered_map< CNTK::StreamInformation,std::pair< CNTK::NDArrayViewPtr,CNTK::NDArrayViewPtr >,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,std::pair< CNTK::NDArrayViewPtr,CNTK::NDArrayViewPtr > > > > &computedMeanAndVariances, CNTK::DeviceDescriptor const &device)\n"
    "    void __compute_input_per_dim_means_and_inv_std_devs__(CNTK::MinibatchSourcePtr const &minibatchSource, std::unordered_map< CNTK::StreamInformation,std::pair< CNTK::NDArrayViewPtr,CNTK::NDArrayViewPtr >,std::hash< CNTK::StreamInformation >,std::equal_to< CNTK::StreamInformation >,std::allocator< std::pair< CNTK::StreamInformation const,std::pair< CNTK::NDArrayViewPtr,CNTK::NDArrayViewPtr > > > > &computedMeanAndVariances)\n");
  
  return Qnil;
}

.__constant_initializer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25558

SWIGINTERN VALUE _wrap___constant_initializer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[1];
  int ii;
  
  argc = nargs;
  if (argc > 1) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap___constant_initializer____SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap___constant_initializer____SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "__constant_initializer__", 
    "    CNTK::Dictionary __constant_initializer__(double value)\n"
    "    CNTK::Dictionary __constant_initializer__()\n");
  
  return Qnil;
}

.convolution(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 46843

SWIGINTERN VALUE _wrap___convolution__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs;
  if (argc > 9) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___convolution____SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          return _wrap___convolution____SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<bool,std::allocator< bool > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___convolution____SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<bool,std::allocator< bool > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___convolution____SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<bool,std::allocator< bool > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                // '1000' is the typecheck precedence code. It means: check after basic
                // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                _v = NIL_P(rb_check_array_type(argv[5])) ? 0 : 1;
              }
              if (_v) {
                return _wrap___convolution____SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<bool,std::allocator< bool > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                // '1000' is the typecheck precedence code. It means: check after basic
                // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                _v = NIL_P(rb_check_array_type(argv[5])) ? 0 : 1;
              }
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  return _wrap___convolution____SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<bool,std::allocator< bool > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                // '1000' is the typecheck precedence code. It means: check after basic
                // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                _v = NIL_P(rb_check_array_type(argv[5])) ? 0 : 1;
              }
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap___convolution____SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector<bool,std::allocator< bool > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                // '1000' is the typecheck precedence code. It means: check after basic
                // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                _v = NIL_P(rb_check_array_type(argv[5])) ? 0 : 1;
              }
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_wstring(argv[8], (std::wstring**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap___convolution____SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "__convolution__", 
    "    CNTK::FunctionPtr __convolution__(CNTK::Variable const &convolutionMap, CNTK::Variable const &operand, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &sharing, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad, CNTK::NDShape const &upperPad, size_t maxTempMemSizeInSamples, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __convolution__(CNTK::Variable const &convolutionMap, CNTK::Variable const &operand, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &sharing, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad, CNTK::NDShape const &upperPad, size_t maxTempMemSizeInSamples)\n"
    "    CNTK::FunctionPtr __convolution__(CNTK::Variable const &convolutionMap, CNTK::Variable const &operand, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &sharing, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad, CNTK::NDShape const &upperPad)\n"
    "    CNTK::FunctionPtr __convolution__(CNTK::Variable const &convolutionMap, CNTK::Variable const &operand, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &sharing, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad)\n"
    "    CNTK::FunctionPtr __convolution__(CNTK::Variable const &convolutionMap, CNTK::Variable const &operand, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &sharing, std::vector< bool,std::allocator< bool > > const &autoPadding)\n"
    "    CNTK::FunctionPtr __convolution__(CNTK::Variable const &convolutionMap, CNTK::Variable const &operand, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &sharing)\n"
    "    CNTK::FunctionPtr __convolution__(CNTK::Variable const &convolutionMap, CNTK::Variable const &operand, CNTK::NDShape const &strides)\n"
    "    CNTK::FunctionPtr __convolution__(CNTK::Variable const &convolutionMap, CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.cos(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 35038

SWIGINTERN VALUE _wrap___cos__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___cos____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___cos____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__cos__", 
    "    CNTK::FunctionPtr __cos__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __cos__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__cosine_distance__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 41321

SWIGINTERN VALUE _wrap___cosine_distance__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___cosine_distance____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___cosine_distance____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__cosine_distance__", 
    "    CNTK::FunctionPtr __cosine_distance__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __cosine_distance__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.__create_basic_training_session__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 67605

SWIGINTERN VALUE _wrap___create_basic_training_session__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[13];
  int ii;
  
  argc = nargs;
  if (argc > 13) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Trainer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__Variable_CNTK__StreamInformation_std__hashT_CNTK__Variable_t_std__equal_toT_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_const_CNTK__StreamInformation_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap___create_basic_training_session____SWIG_7(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Trainer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__Variable_CNTK__StreamInformation_std__hashT_CNTK__Variable_t_std__equal_toT_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_const_CNTK__StreamInformation_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap___create_basic_training_session____SWIG_6(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Trainer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__Variable_CNTK__StreamInformation_std__hashT_CNTK__Variable_t_std__equal_toT_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_const_CNTK__StreamInformation_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap___create_basic_training_session____SWIG_5(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Trainer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__Variable_CNTK__StreamInformation_std__hashT_CNTK__Variable_t_std__equal_toT_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_const_CNTK__StreamInformation_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap___create_basic_training_session____SWIG_4(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Trainer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__Variable_CNTK__StreamInformation_std__hashT_CNTK__Variable_t_std__equal_toT_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_const_CNTK__StreamInformation_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap___create_basic_training_session____SWIG_3(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Trainer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__Variable_CNTK__StreamInformation_std__hashT_CNTK__Variable_t_std__equal_toT_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_const_CNTK__StreamInformation_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap___create_basic_training_session____SWIG_2(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Trainer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__Variable_CNTK__StreamInformation_std__hashT_CNTK__Variable_t_std__equal_toT_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_const_CNTK__StreamInformation_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_size_t(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap___create_basic_training_session____SWIG_1(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Trainer_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__unordered_mapT_CNTK__Variable_CNTK__StreamInformation_std__hashT_CNTK__Variable_t_std__equal_toT_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_const_CNTK__StreamInformation_t_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_ConvertPtr(argv[6], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_CNTK__TrainingParameterPerUnitScheduleT_size_t_CNTK__TrainingParameterScheduleT_size_t_t__UnitType__Sample_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_size_t(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_size_t(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap___create_basic_training_session____SWIG_0(nargs, args, self);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 13, "__create_basic_training_session__", 
    "    CNTK::TrainingSessionPtr __create_basic_training_session__(CNTK::MinibatchSourcePtr const &trainingSource, CNTK::TrainerPtr const &trainer, std::unordered_map< CNTK::Variable,CNTK::StreamInformation,std::hash< CNTK::Variable >,std::equal_to< CNTK::Variable >,std::allocator< std::pair< CNTK::Variable const,CNTK::StreamInformation > > > const &modelInputToMinibatchSourceStream, CNTK::MinibatchSizeSchedule const &minibatchSizeSchedule, size_t checkpointFrequencyInSamples, std::wstring const &checkPointFileName, CNTK::MinibatchSourcePtr const &crossValidationSource, CNTK::MinibatchSizeSchedule const &crossValidationSchedule, size_t crossValidationFrequencyInSamples, bool restoreFromCheckpointIfExists, bool keepExistingCheckpoints, size_t maxNumberOfTrainingSamples, size_t progressFrequency)\n"
    "    CNTK::TrainingSessionPtr __create_basic_training_session__(CNTK::MinibatchSourcePtr const &trainingSource, CNTK::TrainerPtr const &trainer, std::unordered_map< CNTK::Variable,CNTK::StreamInformation,std::hash< CNTK::Variable >,std::equal_to< CNTK::Variable >,std::allocator< std::pair< CNTK::Variable const,CNTK::StreamInformation > > > const &modelInputToMinibatchSourceStream, CNTK::MinibatchSizeSchedule const &minibatchSizeSchedule, size_t checkpointFrequencyInSamples, std::wstring const &checkPointFileName, CNTK::MinibatchSourcePtr const &crossValidationSource, CNTK::MinibatchSizeSchedule const &crossValidationSchedule, size_t crossValidationFrequencyInSamples, bool restoreFromCheckpointIfExists, bool keepExistingCheckpoints, size_t maxNumberOfTrainingSamples)\n"
    "    CNTK::TrainingSessionPtr __create_basic_training_session__(CNTK::MinibatchSourcePtr const &trainingSource, CNTK::TrainerPtr const &trainer, std::unordered_map< CNTK::Variable,CNTK::StreamInformation,std::hash< CNTK::Variable >,std::equal_to< CNTK::Variable >,std::allocator< std::pair< CNTK::Variable const,CNTK::StreamInformation > > > const &modelInputToMinibatchSourceStream, CNTK::MinibatchSizeSchedule const &minibatchSizeSchedule, size_t checkpointFrequencyInSamples, std::wstring const &checkPointFileName, CNTK::MinibatchSourcePtr const &crossValidationSource, CNTK::MinibatchSizeSchedule const &crossValidationSchedule, size_t crossValidationFrequencyInSamples, bool restoreFromCheckpointIfExists, bool keepExistingCheckpoints)\n"
    "    CNTK::TrainingSessionPtr __create_basic_training_session__(CNTK::MinibatchSourcePtr const &trainingSource, CNTK::TrainerPtr const &trainer, std::unordered_map< CNTK::Variable,CNTK::StreamInformation,std::hash< CNTK::Variable >,std::equal_to< CNTK::Variable >,std::allocator< std::pair< CNTK::Variable const,CNTK::StreamInformation > > > const &modelInputToMinibatchSourceStream, CNTK::MinibatchSizeSchedule const &minibatchSizeSchedule, size_t checkpointFrequencyInSamples, std::wstring const &checkPointFileName, CNTK::MinibatchSourcePtr const &crossValidationSource, CNTK::MinibatchSizeSchedule const &crossValidationSchedule, size_t crossValidationFrequencyInSamples, bool restoreFromCheckpointIfExists)\n"
    "    CNTK::TrainingSessionPtr __create_basic_training_session__(CNTK::MinibatchSourcePtr const &trainingSource, CNTK::TrainerPtr const &trainer, std::unordered_map< CNTK::Variable,CNTK::StreamInformation,std::hash< CNTK::Variable >,std::equal_to< CNTK::Variable >,std::allocator< std::pair< CNTK::Variable const,CNTK::StreamInformation > > > const &modelInputToMinibatchSourceStream, CNTK::MinibatchSizeSchedule const &minibatchSizeSchedule, size_t checkpointFrequencyInSamples, std::wstring const &checkPointFileName, CNTK::MinibatchSourcePtr const &crossValidationSource, CNTK::MinibatchSizeSchedule const &crossValidationSchedule, size_t crossValidationFrequencyInSamples)\n"
    "    CNTK::TrainingSessionPtr __create_basic_training_session__(CNTK::MinibatchSourcePtr const &trainingSource, CNTK::TrainerPtr const &trainer, std::unordered_map< CNTK::Variable,CNTK::StreamInformation,std::hash< CNTK::Variable >,std::equal_to< CNTK::Variable >,std::allocator< std::pair< CNTK::Variable const,CNTK::StreamInformation > > > const &modelInputToMinibatchSourceStream, CNTK::MinibatchSizeSchedule const &minibatchSizeSchedule, size_t checkpointFrequencyInSamples, std::wstring const &checkPointFileName, CNTK::MinibatchSourcePtr const &crossValidationSource, CNTK::MinibatchSizeSchedule const &crossValidationSchedule)\n"
    "    CNTK::TrainingSessionPtr __create_basic_training_session__(CNTK::MinibatchSourcePtr const &trainingSource, CNTK::TrainerPtr const &trainer, std::unordered_map< CNTK::Variable,CNTK::StreamInformation,std::hash< CNTK::Variable >,std::equal_to< CNTK::Variable >,std::allocator< std::pair< CNTK::Variable const,CNTK::StreamInformation > > > const &modelInputToMinibatchSourceStream, CNTK::MinibatchSizeSchedule const &minibatchSizeSchedule, size_t checkpointFrequencyInSamples, std::wstring const &checkPointFileName, CNTK::MinibatchSourcePtr const &crossValidationSource)\n"
    "    CNTK::TrainingSessionPtr __create_basic_training_session__(CNTK::MinibatchSourcePtr const &trainingSource, CNTK::TrainerPtr const &trainer, std::unordered_map< CNTK::Variable,CNTK::StreamInformation,std::hash< CNTK::Variable >,std::equal_to< CNTK::Variable >,std::allocator< std::pair< CNTK::Variable const,CNTK::StreamInformation > > > const &modelInputToMinibatchSourceStream, CNTK::MinibatchSizeSchedule const &minibatchSizeSchedule, size_t checkpointFrequencyInSamples, std::wstring const &checkPointFileName)\n");
  
  return Qnil;
}

.__create_composite_minibatch_source__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 62015

SWIGINTERN VALUE
_wrap___create_composite_minibatch_source__(int argc, VALUE *argv, VALUE self) {
  CNTK::Dictionary *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  CNTK::MinibatchSourcePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_CNTK__Dictionary,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::Dictionary const &","CNTK::CreateCompositeMinibatchSource", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "CNTK::Dictionary const &","CNTK::CreateCompositeMinibatchSource", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< CNTK::Dictionary * >(argp1);
  {
    try {
      result = CNTK::CreateCompositeMinibatchSource((CNTK::Dictionary const &)*arg1); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  {
    std::shared_ptr<  CNTK::MinibatchSource > *smartresult = result ? new std::shared_ptr<  CNTK::MinibatchSource >(result) : 0;
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_CNTK__MinibatchSource_t, SWIG_POINTER_OWN);
  }
  return vresult;
fail:
  return Qnil;
}

.__create_trainer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 59970

SWIGINTERN VALUE _wrap___create_trainer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::shared_ptr< CNTK::Learner >,std::allocator< std::shared_ptr< CNTK::Learner > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___create_trainer____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::shared_ptr< CNTK::Learner >,std::allocator< std::shared_ptr< CNTK::Learner > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___create_trainer____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__create_trainer__", 
    "    CNTK::TrainerPtr __create_trainer__(CNTK::FunctionPtr const &model, CNTK::FunctionPtr const &lossFunction, std::vector< CNTK::LearnerPtr,std::allocator< CNTK::LearnerPtr > > const &parameterLearners)\n"
    "    CNTK::TrainerPtr __create_trainer__(CNTK::FunctionPtr const &model, CNTK::FunctionPtr const &lossFunction, CNTK::FunctionPtr const &evaluationFunction, std::vector< CNTK::LearnerPtr,std::allocator< CNTK::LearnerPtr > > const &parameterLearners)\n");
  
  return Qnil;
}

.__cross_entropy_with_softmax__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 42228

SWIGINTERN VALUE _wrap___cross_entropy_with_softmax__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___cross_entropy_with_softmax____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___cross_entropy_with_softmax____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___cross_entropy_with_softmax____SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___cross_entropy_with_softmax____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__cross_entropy_with_softmax__", 
    "    CNTK::FunctionPtr __cross_entropy_with_softmax__(CNTK::Variable const &prediction, CNTK::Variable const &labels, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __cross_entropy_with_softmax__(CNTK::Variable const &prediction, CNTK::Variable const &labels, CNTK::Axis const &axis)\n"
    "    CNTK::FunctionPtr __cross_entropy_with_softmax__(CNTK::Variable const &prediction, CNTK::Variable const &labels, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __cross_entropy_with_softmax__(CNTK::Variable const &prediction, CNTK::Variable const &labels)\n");
  
  return Qnil;
}

.__data_type_name__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 17542

SWIGINTERN VALUE
_wrap___data_type_name__(int argc, VALUE *argv, VALUE self) {
  enum CNTK::DataType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "enum CNTK::DataType","CNTK::DataTypeName", 1, argv[0] ));
  } 
  arg1 = static_cast< enum CNTK::DataType >(val1);
  {
    try {
      result = (char *)CNTK::DataTypeName(arg1); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

.__data_type_size__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 17582

SWIGINTERN VALUE
_wrap___data_type_size__(int argc, VALUE *argv, VALUE self) {
  enum CNTK::DataType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "enum CNTK::DataType","CNTK::DataTypeSize", 1, argv[0] ));
  } 
  arg1 = static_cast< enum CNTK::DataType >(val1);
  {
    try {
      result = CNTK::DataTypeSize(arg1); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

.dropout(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 37744

SWIGINTERN VALUE _wrap___dropout__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___dropout____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___dropout____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__dropout__", 
    "    CNTK::FunctionPtr __dropout__(CNTK::Variable const &operand, double dropoutRate, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __dropout__(CNTK::Variable const &operand, double dropoutRate)\n");
  
  return Qnil;
}

.__edit_distance_error__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 42547

SWIGINTERN VALUE _wrap___edit_distance_error__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs;
  if (argc > 8) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< size_t,std::allocator< size_t > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap___edit_distance_error____SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                int res = swig::asptr(argv[6], (std::vector< size_t,std::allocator< size_t > >**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  int res = SWIG_AsPtr_std_wstring(argv[7], (std::wstring**)(0));
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap___edit_distance_error____SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "__edit_distance_error__", 
    "    CNTK::FunctionPtr __edit_distance_error__(CNTK::Variable const &prediction, CNTK::Variable const &labels, float substitutionPenalty, float deletionPenalty, float insertionPenalty, bool squashInputs, std::vector< size_t,std::allocator< size_t > > const &samplesToIgnore, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __edit_distance_error__(CNTK::Variable const &prediction, CNTK::Variable const &labels, float substitutionPenalty, float deletionPenalty, float insertionPenalty, bool squashInputs, std::vector< size_t,std::allocator< size_t > > const &samplesToIgnore)\n");
  
  return Qnil;
}

.__element_divide__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 39091

SWIGINTERN VALUE _wrap___element_divide__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___element_divide____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___element_divide____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__element_divide__", 
    "    CNTK::FunctionPtr __element_divide__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __element_divide__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.__element_select__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 51525

SWIGINTERN VALUE _wrap___element_select__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___element_select____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___element_select____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__element_select__", 
    "    CNTK::FunctionPtr __element_select__(CNTK::Variable const &condition, CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __element_select__(CNTK::Variable const &condition, CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.__element_times__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 38910

SWIGINTERN VALUE _wrap___element_times__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___element_times____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___element_times____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__element_times__", 
    "    CNTK::FunctionPtr __element_times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __element_times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.equal(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 39272

SWIGINTERN VALUE _wrap___equal__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___equal____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___equal____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__equal__", 
    "    CNTK::FunctionPtr __equal__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __equal__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.exp(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 35336

SWIGINTERN VALUE _wrap___exp__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___exp____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___exp____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__exp__", 
    "    CNTK::FunctionPtr __exp__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __exp__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.first(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 52708

SWIGINTERN VALUE _wrap___first__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___first____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___first____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__first__", 
    "    CNTK::FunctionPtr __first__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __first__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.floor(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 36081

SWIGINTERN VALUE _wrap___floor__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___floor____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___floor____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__floor__", 
    "    CNTK::FunctionPtr __floor__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __floor__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__future_value__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 44547

SWIGINTERN VALUE _wrap___future_value__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___future_value____SWIG_5(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___future_value____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___future_value____SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___future_value____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___future_value____SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___future_value____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__future_value__", 
    "    CNTK::FunctionPtr __future_value__(CNTK::Variable const &operand, CNTK::Variable const &initialState, size_t offset, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __future_value__(CNTK::Variable const &operand, CNTK::Variable const &initialState, size_t offset)\n"
    "    CNTK::FunctionPtr __future_value__(CNTK::Variable const &operand, CNTK::Variable const &initialState)\n"
    "    CNTK::FunctionPtr __future_value__(CNTK::Variable const &operand, size_t offset, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __future_value__(CNTK::Variable const &operand, size_t offset)\n"
    "    CNTK::FunctionPtr __future_value__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.gather(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 53177

SWIGINTERN VALUE _wrap___gather__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gather____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___gather____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__gather__", 
    "    CNTK::FunctionPtr __gather__(CNTK::Variable const &operand, CNTK::Variable const &condition, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __gather__(CNTK::Variable const &operand, CNTK::Variable const &condition)\n");
  
  return Qnil;
}

.__get_max_num_cputhreads__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 68254

SWIGINTERN VALUE
_wrap___get_max_num_cputhreads__(int argc, VALUE *argv, VALUE self) {
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = CNTK::GetMaxNumCPUThreads(); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

.__glorot_normal_initializer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 26955

SWIGINTERN VALUE _wrap___glorot_normal_initializer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap___glorot_normal_initializer____SWIG_4(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap___glorot_normal_initializer____SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___glorot_normal_initializer____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___glorot_normal_initializer____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___glorot_normal_initializer____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__glorot_normal_initializer__", 
    "    CNTK::Dictionary __glorot_normal_initializer__(double scale, int outputRank, int filterRank, unsigned long seed)\n"
    "    CNTK::Dictionary __glorot_normal_initializer__(double scale, int outputRank, int filterRank)\n"
    "    CNTK::Dictionary __glorot_normal_initializer__(double scale, int outputRank)\n"
    "    CNTK::Dictionary __glorot_normal_initializer__(double scale)\n"
    "    CNTK::Dictionary __glorot_normal_initializer__()\n");
  
  return Qnil;
}

.__glorot_uniform_initializer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 26613

SWIGINTERN VALUE _wrap___glorot_uniform_initializer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap___glorot_uniform_initializer____SWIG_4(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap___glorot_uniform_initializer____SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___glorot_uniform_initializer____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___glorot_uniform_initializer____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___glorot_uniform_initializer____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__glorot_uniform_initializer__", 
    "    CNTK::Dictionary __glorot_uniform_initializer__(double scale, int outputRank, int filterRank, unsigned long seed)\n"
    "    CNTK::Dictionary __glorot_uniform_initializer__(double scale, int outputRank, int filterRank)\n"
    "    CNTK::Dictionary __glorot_uniform_initializer__(double scale, int outputRank)\n"
    "    CNTK::Dictionary __glorot_uniform_initializer__(double scale)\n"
    "    CNTK::Dictionary __glorot_uniform_initializer__()\n");
  
  return Qnil;
}

.greater(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 39996

SWIGINTERN VALUE _wrap___greater__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___greater____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___greater____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__greater__", 
    "    CNTK::FunctionPtr __greater__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __greater__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.__greater_equal__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 40177

SWIGINTERN VALUE _wrap___greater_equal__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___greater_equal____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___greater_equal____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__greater_equal__", 
    "    CNTK::FunctionPtr __greater_equal__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __greater_equal__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.hardmax(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 36826

SWIGINTERN VALUE _wrap___hardmax__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___hardmax____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___hardmax____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__hardmax__", 
    "    CNTK::FunctionPtr __hardmax__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __hardmax__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__he_normal_initializer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 27639

SWIGINTERN VALUE _wrap___he_normal_initializer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap___he_normal_initializer____SWIG_4(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap___he_normal_initializer____SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___he_normal_initializer____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___he_normal_initializer____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___he_normal_initializer____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__he_normal_initializer__", 
    "    CNTK::Dictionary __he_normal_initializer__(double scale, int outputRank, int filterRank, unsigned long seed)\n"
    "    CNTK::Dictionary __he_normal_initializer__(double scale, int outputRank, int filterRank)\n"
    "    CNTK::Dictionary __he_normal_initializer__(double scale, int outputRank)\n"
    "    CNTK::Dictionary __he_normal_initializer__(double scale)\n"
    "    CNTK::Dictionary __he_normal_initializer__()\n");
  
  return Qnil;
}

.__he_uniform_initializer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 27297

SWIGINTERN VALUE _wrap___he_uniform_initializer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap___he_uniform_initializer____SWIG_4(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap___he_uniform_initializer____SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___he_uniform_initializer____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___he_uniform_initializer____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___he_uniform_initializer____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__he_uniform_initializer__", 
    "    CNTK::Dictionary __he_uniform_initializer__(double scale, int outputRank, int filterRank, unsigned long seed)\n"
    "    CNTK::Dictionary __he_uniform_initializer__(double scale, int outputRank, int filterRank)\n"
    "    CNTK::Dictionary __he_uniform_initializer__(double scale, int outputRank)\n"
    "    CNTK::Dictionary __he_uniform_initializer__(double scale)\n"
    "    CNTK::Dictionary __he_uniform_initializer__()\n");
  
  return Qnil;
}

.__input_variable__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25264

SWIGINTERN VALUE _wrap___input_variable__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[6];
  int ii;
  
  argc = nargs;
  if (argc > 6) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 5) {
    int _v;
    {
      // '1000' is the typecheck precedence code. It means: check after basic
      // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
      _v = NIL_P(rb_check_array_type(argv[0])) ? 0 : 1;
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_wstring(argv[4], (std::wstring**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___input_variable____SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      // '1000' is the typecheck precedence code. It means: check after basic
      // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
      _v = NIL_P(rb_check_array_type(argv[0])) ? 0 : 1;
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_wstring(argv[4], (std::wstring**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector< CNTK::Axis,std::allocator< CNTK::Axis > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap___input_variable____SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "__input_variable__", 
    "    CNTK::Variable __input_variable__(CNTK::NDShape const &shape, bool isSparse, enum CNTK::DataType dataType, bool needsGradient, std::wstring const &name, std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > const &dynamicAxes)\n"
    "    CNTK::Variable __input_variable__(CNTK::NDShape const &shape, bool isSparse, enum CNTK::DataType dataType, bool needsGradient, std::wstring const &name)\n");
  
  return Qnil;
}

.__is_first__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 52410

SWIGINTERN VALUE _wrap___is_first__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___is_first____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___is_first____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__is_first__", 
    "    CNTK::FunctionPtr __is_first__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __is_first__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__is_last__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 52559

SWIGINTERN VALUE _wrap___is_last__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___is_last____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___is_last____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__is_last__", 
    "    CNTK::FunctionPtr __is_last__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __is_last__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__lambda_rank__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 43405

SWIGINTERN VALUE _wrap___lambda_rank__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___lambda_rank____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___lambda_rank____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__lambda_rank__", 
    "    CNTK::FunctionPtr __lambda_rank__(CNTK::Variable const &prediction, CNTK::Variable const &gains, CNTK::Variable const &groupId, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __lambda_rank__(CNTK::Variable const &prediction, CNTK::Variable const &gains, CNTK::Variable const &groupId)\n");
  
  return Qnil;
}

.last(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 52857

SWIGINTERN VALUE _wrap___last__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___last____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___last____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__last__", 
    "    CNTK::FunctionPtr __last__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __last__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.less(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 39634

SWIGINTERN VALUE _wrap___less__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___less____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___less____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__less__", 
    "    CNTK::FunctionPtr __less__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __less__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.__less_equal__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 39815

SWIGINTERN VALUE _wrap___less_equal__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___less_equal____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___less_equal____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__less_equal__", 
    "    CNTK::FunctionPtr __less_equal__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __less_equal__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.log(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 35485

SWIGINTERN VALUE _wrap___log__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___log____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___log____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__log__", 
    "    CNTK::FunctionPtr __log__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __log__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__log_add_exp__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 38729

SWIGINTERN VALUE _wrap___log_add_exp__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___log_add_exp____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___log_add_exp____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__log_add_exp__", 
    "    CNTK::FunctionPtr __log_add_exp__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __log_add_exp__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.minus(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 38548

SWIGINTERN VALUE _wrap___minus__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___minus____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___minus____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__minus__", 
    "    CNTK::FunctionPtr __minus__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __minus__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.__momentum_sgdlearner__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 56401

SWIGINTERN VALUE _wrap___momentum_sgdlearner__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___momentum_sgdlearner____SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___momentum_sgdlearner____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__AdditionalLearningOptions, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___momentum_sgdlearner____SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__momentum_sgdlearner__", 
    "    CNTK::LearnerPtr __momentum_sgdlearner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule, bool unitGain, CNTK::AdditionalLearningOptions additionalOptions)\n"
    "    CNTK::LearnerPtr __momentum_sgdlearner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule, bool unitGain)\n"
    "    CNTK::LearnerPtr __momentum_sgdlearner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule)\n");
  
  return Qnil;
}

.mpicommunicator(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 63957

SWIGINTERN VALUE
_wrap___mpicommunicator__(int argc, VALUE *argv, VALUE self) {
  CNTK::DistributedCommunicatorPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = CNTK::MPICommunicator(); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  {
    std::shared_ptr<  CNTK::DistributedCommunicator > *smartresult = result ? new std::shared_ptr<  CNTK::DistributedCommunicator >(result) : 0;
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_CNTK__DistributedCommunicator_t, SWIG_POINTER_OWN);
  }
  return vresult;
fail:
  return Qnil;
}

.ndcgat1(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 43618

SWIGINTERN VALUE _wrap___ndcgat1__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___ndcgat1____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___ndcgat1____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__ndcgat1__", 
    "    CNTK::FunctionPtr __ndcgat1__(CNTK::Variable const &prediction, CNTK::Variable const &gains, CNTK::Variable const &groupId, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __ndcgat1__(CNTK::Variable const &prediction, CNTK::Variable const &gains, CNTK::Variable const &groupId)\n");
  
  return Qnil;
}

.negate(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 34442

SWIGINTERN VALUE _wrap___negate__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___negate____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___negate____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__negate__", 
    "    CNTK::FunctionPtr __negate__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __negate__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__nesterov_learner__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 56739

SWIGINTERN VALUE _wrap___nesterov_learner__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___nesterov_learner____SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___nesterov_learner____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__MomentumSchedule, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_CNTK__AdditionalLearningOptions, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___nesterov_learner____SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__nesterov_learner__", 
    "    CNTK::LearnerPtr __nesterov_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule, bool unitGain, CNTK::AdditionalLearningOptions additionalOptions)\n"
    "    CNTK::LearnerPtr __nesterov_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule, bool unitGain)\n"
    "    CNTK::LearnerPtr __nesterov_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::MomentumSchedule const &momentumSchedule)\n");
  
  return Qnil;
}

.__normal_initializer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25933

SWIGINTERN VALUE _wrap___normal_initializer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap___normal_initializer____SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___normal_initializer____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___normal_initializer____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___normal_initializer____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__normal_initializer__", 
    "    CNTK::Dictionary __normal_initializer__(double scale, int outputRank, int filterRank, unsigned long seed)\n"
    "    CNTK::Dictionary __normal_initializer__(double scale, int outputRank, int filterRank)\n"
    "    CNTK::Dictionary __normal_initializer__(double scale, int outputRank)\n"
    "    CNTK::Dictionary __normal_initializer__(double scale)\n");
  
  return Qnil;
}

.__not_equal__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 39453

SWIGINTERN VALUE _wrap___not_equal__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___not_equal____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___not_equal____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__not_equal__", 
    "    CNTK::FunctionPtr __not_equal__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __not_equal__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.__optimized_rnnstack__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 51005

SWIGINTERN VALUE _wrap___optimized_rnnstack__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs;
  if (argc > 7) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___optimized_rnnstack____SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap___optimized_rnnstack____SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap___optimized_rnnstack____SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_wstring(argv[5], (std::wstring**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_wstring(argv[6], (std::wstring**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap___optimized_rnnstack____SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "__optimized_rnnstack__", 
    "    CNTK::FunctionPtr __optimized_rnnstack__(CNTK::Variable const &operand, CNTK::Variable const &weights, size_t hiddenSize, size_t numLayers, bool bidirectional, std::wstring const &recurrentOp, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __optimized_rnnstack__(CNTK::Variable const &operand, CNTK::Variable const &weights, size_t hiddenSize, size_t numLayers, bool bidirectional, std::wstring const &recurrentOp)\n"
    "    CNTK::FunctionPtr __optimized_rnnstack__(CNTK::Variable const &operand, CNTK::Variable const &weights, size_t hiddenSize, size_t numLayers, bool bidirectional)\n"
    "    CNTK::FunctionPtr __optimized_rnnstack__(CNTK::Variable const &operand, CNTK::Variable const &weights, size_t hiddenSize, size_t numLayers)\n");
  
  return Qnil;
}

.__output_variable__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25354

SWIGINTERN VALUE
_wrap___output_variable__(int argc, VALUE *argv, VALUE self) {
  CNTK::NDShape *arg1 = 0 ;
  enum CNTK::DataType arg2 ;
  std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > *arg3 = 0 ;
  std::wstring *arg4 = 0 ;
  CNTK::NDShape tmp1 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  SwigValueWrapper< CNTK::Variable > result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  {
    VALUE arry = rb_check_array_type(argv[0]);
    if(NIL_P(arry)) {
      rb_raise(rb_eArgError, "Array expected"); SWIG_fail;
    }else{
      size_t rank = RARRAY_LEN(arry);
      std::vector<size_t> dimensions(rank);
      for (int i=0; i < rank; i++) {
        VALUE elt = RARRAY_AREF(arry, i);
        dimensions[rank-i-1] = NUM2SIZET(elt);
      }
      tmp1 = CNTK::NDShape(dimensions);
      arg1 = &tmp1;
    }
  }
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "enum CNTK::DataType","CNTK::OutputVariable", 2, argv[1] ));
  } 
  arg2 = static_cast< enum CNTK::DataType >(val2);
  {
    std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > *ptr = (std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > const &","CNTK::OutputVariable", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > const &","CNTK::OutputVariable", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  {
    std::wstring *ptr = (std::wstring *)0;
    res4 = SWIG_AsPtr_std_wstring(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::wstring const &","CNTK::OutputVariable", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::wstring const &","CNTK::OutputVariable", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = CNTK::OutputVariable((CNTK::NDShape const &)*arg1,arg2,(std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > const &)*arg3,(std::wstring const &)*arg4); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_NewPointerObj((new CNTK::Variable(static_cast< const CNTK::Variable& >(result))), SWIGTYPE_p_CNTK__Variable, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}

.__past_value__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 44051

SWIGINTERN VALUE _wrap___past_value__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___past_value____SWIG_5(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___past_value____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___past_value____SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___past_value____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___past_value____SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___past_value____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__past_value__", 
    "    CNTK::FunctionPtr __past_value__(CNTK::Variable const &operand, CNTK::Variable const &initialState, size_t offset, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __past_value__(CNTK::Variable const &operand, CNTK::Variable const &initialState, size_t offset)\n"
    "    CNTK::FunctionPtr __past_value__(CNTK::Variable const &operand, CNTK::Variable const &initialState)\n"
    "    CNTK::FunctionPtr __past_value__(CNTK::Variable const &operand, size_t offset, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __past_value__(CNTK::Variable const &operand, size_t offset)\n"
    "    CNTK::FunctionPtr __past_value__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__per_dim_mean_variance_normalize__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 45895

SWIGINTERN VALUE _wrap___per_dim_mean_variance_normalize__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__NDArrayView_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__NDArrayView_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___per_dim_mean_variance_normalize____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__NDArrayView_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__NDArrayView_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___per_dim_mean_variance_normalize____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__per_dim_mean_variance_normalize__", 
    "    CNTK::FunctionPtr __per_dim_mean_variance_normalize__(CNTK::Variable const &operand, CNTK::NDArrayViewPtr const &mean, CNTK::NDArrayViewPtr const &invStdDev, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __per_dim_mean_variance_normalize__(CNTK::Variable const &operand, CNTK::NDArrayViewPtr const &mean, CNTK::NDArrayViewPtr const &invStdDev)\n");
  
  return Qnil;
}

.__placeholder_variable__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 24994

SWIGINTERN VALUE
_wrap___placeholder_variable__(int argc, VALUE *argv, VALUE self) {
  CNTK::NDShape *arg1 = 0 ;
  std::wstring *arg2 = 0 ;
  std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > *arg3 = 0 ;
  CNTK::NDShape tmp1 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< CNTK::Variable > result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  {
    VALUE arry = rb_check_array_type(argv[0]);
    if(NIL_P(arry)) {
      rb_raise(rb_eArgError, "Array expected"); SWIG_fail;
    }else{
      size_t rank = RARRAY_LEN(arry);
      std::vector<size_t> dimensions(rank);
      for (int i=0; i < rank; i++) {
        VALUE elt = RARRAY_AREF(arry, i);
        dimensions[rank-i-1] = NUM2SIZET(elt);
      }
      tmp1 = CNTK::NDShape(dimensions);
      arg1 = &tmp1;
    }
  }
  {
    std::wstring *ptr = (std::wstring *)0;
    res2 = SWIG_AsPtr_std_wstring(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::wstring const &","CNTK::PlaceholderVariable", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::wstring const &","CNTK::PlaceholderVariable", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > *ptr = (std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > const &","CNTK::PlaceholderVariable", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > const &","CNTK::PlaceholderVariable", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = CNTK::PlaceholderVariable((CNTK::NDShape const &)*arg1,(std::wstring const &)*arg2,(std::vector< CNTK::Axis,std::allocator< CNTK::Axis > > const &)*arg3); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_NewPointerObj((new CNTK::Variable(static_cast< const CNTK::Variable& >(result))), SWIGTYPE_p_CNTK__Variable, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}

.plus(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 38367

SWIGINTERN VALUE _wrap___plus__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___plus____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___plus____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__plus__", 
    "    CNTK::FunctionPtr __plus__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __plus__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.pooling(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 48192

SWIGINTERN VALUE _wrap___pooling__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs;
  if (argc > 9) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          return _wrap___pooling____SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            return _wrap___pooling____SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___pooling____SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                // '1000' is the typecheck precedence code. It means: check after basic
                // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                _v = NIL_P(rb_check_array_type(argv[5])) ? 0 : 1;
              }
              if (_v) {
                return _wrap___pooling____SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                // '1000' is the typecheck precedence code. It means: check after basic
                // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                _v = NIL_P(rb_check_array_type(argv[5])) ? 0 : 1;
              }
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  return _wrap___pooling____SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                // '1000' is the typecheck precedence code. It means: check after basic
                // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                _v = NIL_P(rb_check_array_type(argv[5])) ? 0 : 1;
              }
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap___pooling____SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            int res = swig::asptr(argv[4], (std::vector<bool,std::allocator< bool > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                // '1000' is the typecheck precedence code. It means: check after basic
                // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                _v = NIL_P(rb_check_array_type(argv[5])) ? 0 : 1;
              }
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_wstring(argv[8], (std::wstring**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap___pooling____SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "__pooling__", 
    "    CNTK::FunctionPtr __pooling__(CNTK::Variable const &operand, CNTK::PoolingType poolingType, CNTK::NDShape const &poolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad, CNTK::NDShape const &upperPad, bool const ceilOutDim, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __pooling__(CNTK::Variable const &operand, CNTK::PoolingType poolingType, CNTK::NDShape const &poolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad, CNTK::NDShape const &upperPad, bool const ceilOutDim)\n"
    "    CNTK::FunctionPtr __pooling__(CNTK::Variable const &operand, CNTK::PoolingType poolingType, CNTK::NDShape const &poolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad, CNTK::NDShape const &upperPad)\n"
    "    CNTK::FunctionPtr __pooling__(CNTK::Variable const &operand, CNTK::PoolingType poolingType, CNTK::NDShape const &poolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad)\n"
    "    CNTK::FunctionPtr __pooling__(CNTK::Variable const &operand, CNTK::PoolingType poolingType, CNTK::NDShape const &poolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding)\n"
    "    CNTK::FunctionPtr __pooling__(CNTK::Variable const &operand, CNTK::PoolingType poolingType, CNTK::NDShape const &poolingWindowShape, CNTK::NDShape const &strides)\n"
    "    CNTK::FunctionPtr __pooling__(CNTK::Variable const &operand, CNTK::PoolingType poolingType, CNTK::NDShape const &poolingWindowShape)\n");
  
  return Qnil;
}

.__quantized_mpicommunicator__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 63992

SWIGINTERN VALUE
_wrap___quantized_mpicommunicator__(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool arg2 ;
  size_t arg3 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  CNTK::QuantizedDistributedCommunicatorPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","CNTK::QuantizedMPICommunicator", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","CNTK::QuantizedMPICommunicator", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","CNTK::QuantizedMPICommunicator", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  {
    try {
      result = CNTK::QuantizedMPICommunicator(arg1,arg2,arg3); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  {
    std::shared_ptr<  CNTK::QuantizedDistributedCommunicator > *smartresult = result ? new std::shared_ptr<  CNTK::QuantizedDistributedCommunicator >(result) : 0;
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_CNTK__QuantizedDistributedCommunicator_t, SWIG_POINTER_OWN);
  }
  return vresult;
fail:
  return Qnil;
}

.__random_initializer_with_rank__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 27789

SWIGINTERN VALUE
_wrap___random_initializer_with_rank__(int argc, VALUE *argv, VALUE self) {
  CNTK::Dictionary *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  CNTK::Dictionary result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_CNTK__Dictionary,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::Dictionary const &","CNTK::RandomInitializerWithRank", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "CNTK::Dictionary const &","CNTK::RandomInitializerWithRank", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< CNTK::Dictionary * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","CNTK::RandomInitializerWithRank", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","CNTK::RandomInitializerWithRank", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = CNTK::RandomInitializerWithRank((CNTK::Dictionary const &)*arg1,arg2,arg3); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_NewPointerObj((new CNTK::Dictionary(static_cast< const CNTK::Dictionary& >(result))), SWIGTYPE_p_CNTK__Dictionary, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

.__random_sample__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 37467

SWIGINTERN VALUE
_wrap___random_sample__(int argc, VALUE *argv, VALUE self) {
  CNTK::Variable *arg1 = 0 ;
  size_t arg2 ;
  bool arg3 ;
  std::wstring *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  CNTK::FunctionPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_CNTK__Variable,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::Variable const &","CNTK::RandomSample", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "CNTK::Variable const &","CNTK::RandomSample", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< CNTK::Variable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","CNTK::RandomSample", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","CNTK::RandomSample", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::wstring *ptr = (std::wstring *)0;
    res4 = SWIG_AsPtr_std_wstring(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::wstring const &","CNTK::RandomSample", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::wstring const &","CNTK::RandomSample", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = CNTK::RandomSample((CNTK::Variable const &)*arg1,arg2,arg3,(std::wstring const &)*arg4); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  {
    std::shared_ptr<  CNTK::Function > *smartresult = result ? new std::shared_ptr<  CNTK::Function >(result) : 0;
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}

.__random_sample_inclusion_frequency__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 37544

SWIGINTERN VALUE
_wrap___random_sample_inclusion_frequency__(int argc, VALUE *argv, VALUE self) {
  CNTK::Variable *arg1 = 0 ;
  size_t arg2 ;
  bool arg3 ;
  std::wstring *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  CNTK::FunctionPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_CNTK__Variable,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::Variable const &","CNTK::RandomSampleInclusionFrequency", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "CNTK::Variable const &","CNTK::RandomSampleInclusionFrequency", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< CNTK::Variable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","CNTK::RandomSampleInclusionFrequency", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","CNTK::RandomSampleInclusionFrequency", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::wstring *ptr = (std::wstring *)0;
    res4 = SWIG_AsPtr_std_wstring(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::wstring const &","CNTK::RandomSampleInclusionFrequency", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::wstring const &","CNTK::RandomSampleInclusionFrequency", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  {
    try {
      result = CNTK::RandomSampleInclusionFrequency((CNTK::Variable const &)*arg1,arg2,arg3,(std::wstring const &)*arg4); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  {
    std::shared_ptr<  CNTK::Function > *smartresult = result ? new std::shared_ptr<  CNTK::Function >(result) : 0;
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_CNTK__Function_t, SWIG_POINTER_OWN);
  }
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}

.__re_lu__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 35187

SWIGINTERN VALUE _wrap___re_lu__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___re_lu____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___re_lu____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__re_lu__", 
    "    CNTK::FunctionPtr __re_lu__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __re_lu__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.reciprocal(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 36528

SWIGINTERN VALUE _wrap___reciprocal__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___reciprocal____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___reciprocal____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__reciprocal__", 
    "    CNTK::FunctionPtr __reciprocal__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reciprocal__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__reduce_log_sum__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 45113

SWIGINTERN VALUE _wrap___reduce_log_sum__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___reduce_log_sum____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___reduce_log_sum____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__reduce_log_sum__", 
    "    CNTK::FunctionPtr __reduce_log_sum__(CNTK::Variable const &operand, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reduce_log_sum__(CNTK::Variable const &operand, CNTK::Axis const &axis)\n");
  
  return Qnil;
}

.__reduce_max__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 45475

SWIGINTERN VALUE _wrap___reduce_max__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___reduce_max____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___reduce_max____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__reduce_max__", 
    "    CNTK::FunctionPtr __reduce_max__(CNTK::Variable const &operand, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reduce_max__(CNTK::Variable const &operand, CNTK::Axis const &axis)\n");
  
  return Qnil;
}

.__reduce_mean__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 45294

SWIGINTERN VALUE _wrap___reduce_mean__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___reduce_mean____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___reduce_mean____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__reduce_mean__", 
    "    CNTK::FunctionPtr __reduce_mean__(CNTK::Variable const &operand, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reduce_mean__(CNTK::Variable const &operand, CNTK::Axis const &axis)\n");
  
  return Qnil;
}

.__reduce_min__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 45656

SWIGINTERN VALUE _wrap___reduce_min__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___reduce_min____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___reduce_min____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__reduce_min__", 
    "    CNTK::FunctionPtr __reduce_min__(CNTK::Variable const &operand, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reduce_min__(CNTK::Variable const &operand, CNTK::Axis const &axis)\n");
  
  return Qnil;
}

.__reduce_sum__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 44908

SWIGINTERN VALUE _wrap___reduce_sum__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___reduce_sum____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___reduce_sum____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___reduce_sum____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___reduce_sum____SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__reduce_sum__", 
    "    CNTK::FunctionPtr __reduce_sum__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reduce_sum__(CNTK::Variable const &operand)\n"
    "    CNTK::FunctionPtr __reduce_sum__(CNTK::Variable const &operand, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reduce_sum__(CNTK::Variable const &operand, CNTK::Axis const &axis)\n");
  
  return Qnil;
}

.reshape(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 38124

SWIGINTERN VALUE _wrap___reshape__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        // '1000' is the typecheck precedence code. It means: check after basic
        // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
        _v = NIL_P(rb_check_array_type(argv[1])) ? 0 : 1;
      }
      if (_v) {
        return _wrap___reshape____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        // '1000' is the typecheck precedence code. It means: check after basic
        // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
        _v = NIL_P(rb_check_array_type(argv[1])) ? 0 : 1;
      }
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___reshape____SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        // '1000' is the typecheck precedence code. It means: check after basic
        // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
        _v = NIL_P(rb_check_array_type(argv[1])) ? 0 : 1;
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___reshape____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        // '1000' is the typecheck precedence code. It means: check after basic
        // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
        _v = NIL_P(rb_check_array_type(argv[1])) ? 0 : 1;
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_wstring(argv[4], (std::wstring**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___reshape____SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__reshape__", 
    "    CNTK::FunctionPtr __reshape__(CNTK::Variable const &operand, CNTK::NDShape const &replacementShape, CNTK::Axis const &beginAxis, CNTK::Axis const &endAxis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reshape__(CNTK::Variable const &operand, CNTK::NDShape const &replacementShape, CNTK::Axis const &beginAxis, CNTK::Axis const &endAxis)\n"
    "    CNTK::FunctionPtr __reshape__(CNTK::Variable const &operand, CNTK::NDShape const &newShape, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __reshape__(CNTK::Variable const &operand, CNTK::NDShape const &newShape)\n");
  
  return Qnil;
}

.__rmsprop_learner__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 57668

SWIGINTERN VALUE _wrap___rmsprop_learner__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs;
  if (argc > 9) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 7) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap___rmsprop_learner____SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap___rmsprop_learner____SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    void *vptr = 0;
                    int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_CNTK__AdditionalLearningOptions, 0);
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap___rmsprop_learner____SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "__rmsprop_learner__", 
    "    CNTK::LearnerPtr __rmsprop_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, double gamma, double inc, double dec, double max, double min, bool needAveMultiplier, CNTK::AdditionalLearningOptions additionalOptions)\n"
    "    CNTK::LearnerPtr __rmsprop_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, double gamma, double inc, double dec, double max, double min, bool needAveMultiplier)\n"
    "    CNTK::LearnerPtr __rmsprop_learner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, double gamma, double inc, double dec, double max, double min)\n");
  
  return Qnil;
}

.roipooling(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 47302

SWIGINTERN VALUE _wrap___roipooling__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          return _wrap___roipooling____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          // '1000' is the typecheck precedence code. It means: check after basic
          // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
          _v = NIL_P(rb_check_array_type(argv[2])) ? 0 : 1;
        }
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___roipooling____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__roipooling__", 
    "    CNTK::FunctionPtr __roipooling__(CNTK::Variable const &convolutionMap, CNTK::Variable const &rois, CNTK::NDShape const &roiOutputShape, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __roipooling__(CNTK::Variable const &convolutionMap, CNTK::Variable const &rois, CNTK::NDShape const &roiOutputShape)\n");
  
  return Qnil;
}

.round(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 35932

SWIGINTERN VALUE _wrap___round__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___round____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___round____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__round__", 
    "    CNTK::FunctionPtr __round__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __round__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.scatter(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 53358

SWIGINTERN VALUE _wrap___scatter__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___scatter____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___scatter____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__scatter__", 
    "    CNTK::FunctionPtr __scatter__(CNTK::Variable const &operand, CNTK::Variable const &condition, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __scatter__(CNTK::Variable const &operand, CNTK::Variable const &condition)\n");
  
  return Qnil;
}

.__set_max_num_cputhreads__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 68217

SWIGINTERN VALUE
_wrap___set_max_num_cputhreads__(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","CNTK::SetMaxNumCPUThreads", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  {
    try {
      CNTK::SetMaxNumCPUThreads(arg1); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  return Qnil;
fail:
  return Qnil;
}

.sgdlearner(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 56104

SWIGINTERN VALUE _wrap___sgdlearner__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___sgdlearner____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__TrainingParameterScheduleT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__AdditionalLearningOptions, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___sgdlearner____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__sgdlearner__", 
    "    CNTK::LearnerPtr __sgdlearner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule, CNTK::AdditionalLearningOptions additionalOptions)\n"
    "    CNTK::LearnerPtr __sgdlearner__(std::vector< CNTK::Parameter,std::allocator< CNTK::Parameter > > const &parameters, CNTK::LearningRateSchedule const &learningRateSchedule)\n");
  
  return Qnil;
}

.sigmoid(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 34591

SWIGINTERN VALUE _wrap___sigmoid__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___sigmoid____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___sigmoid____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__sigmoid__", 
    "    CNTK::FunctionPtr __sigmoid__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __sigmoid__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.sin(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 34889

SWIGINTERN VALUE _wrap___sin__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___sin____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___sin____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__sin__", 
    "    CNTK::FunctionPtr __sin__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __sin__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.slice(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 37391

SWIGINTERN VALUE _wrap___slice__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___slice____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_wstring(argv[4], (std::wstring**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___slice____SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__slice__", 
    "    CNTK::FunctionPtr __slice__(CNTK::Variable const &operand, CNTK::Axis const &axis, int beginIndex, int endIndex, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __slice__(CNTK::Variable const &operand, CNTK::Axis const &axis, int beginIndex, int endIndex)\n");
  
  return Qnil;
}

.softmax(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 36677

SWIGINTERN VALUE _wrap___softmax__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___softmax____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___softmax____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__softmax__", 
    "    CNTK::FunctionPtr __softmax__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __softmax__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.splice(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 51724

SWIGINTERN VALUE _wrap___splice__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Variable,std::allocator< CNTK::Variable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___splice____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< CNTK::Variable,std::allocator< CNTK::Variable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___splice____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__splice__", 
    "    CNTK::FunctionPtr __splice__(std::vector< CNTK::Variable,std::allocator< CNTK::Variable > > const &operands, CNTK::Axis const &axis, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __splice__(std::vector< CNTK::Variable,std::allocator< CNTK::Variable > > const &operands, CNTK::Axis const &axis)\n");
  
  return Qnil;
}

.sqrt(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 35783

SWIGINTERN VALUE _wrap___sqrt__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___sqrt____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___sqrt____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__sqrt__", 
    "    CNTK::FunctionPtr __sqrt__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __sqrt__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.square(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 35634

SWIGINTERN VALUE _wrap___square__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___square____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___square____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__square__", 
    "    CNTK::FunctionPtr __square__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __square__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__squared_error__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 41896

SWIGINTERN VALUE _wrap___squared_error__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[3];
  int ii;
  
  argc = nargs;
  if (argc > 3) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___squared_error____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___squared_error____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__squared_error__", 
    "    CNTK::FunctionPtr __squared_error__(CNTK::Variable const &prediction, CNTK::Variable const &targets, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __squared_error__(CNTK::Variable const &prediction, CNTK::Variable const &targets)\n");
  
  return Qnil;
}

.tanh(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 34740

SWIGINTERN VALUE _wrap___tanh__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___tanh____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___tanh____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__tanh__", 
    "    CNTK::FunctionPtr __tanh__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __tanh__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.times(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 40664

SWIGINTERN VALUE _wrap___times__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs;
  if (argc > 5) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___times____SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___times____SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___times____SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___times____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___times____SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_wstring(argv[4], (std::wstring**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap___times____SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__times__", 
    "    CNTK::FunctionPtr __times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, size_t outputRank, int inferInputRankToMap, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, size_t outputRank, int inferInputRankToMap)\n"
    "    CNTK::FunctionPtr __times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, size_t outputRank, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, size_t outputRank)\n"
    "    CNTK::FunctionPtr __times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.transpose(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 37188

SWIGINTERN VALUE _wrap___transpose__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___transpose____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___transpose____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__transpose__", 
    "    CNTK::FunctionPtr __transpose__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __transpose__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.__transpose_axes__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 37019

SWIGINTERN VALUE _wrap___transpose_axes__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___transpose_axes____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Axis, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___transpose_axes____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__transpose_axes__", 
    "    CNTK::FunctionPtr __transpose_axes__(CNTK::Variable const &operand, CNTK::Axis const &axis1, CNTK::Axis const &axis2, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __transpose_axes__(CNTK::Variable const &operand, CNTK::Axis const &axis1, CNTK::Axis const &axis2)\n");
  
  return Qnil;
}

.__transpose_times__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 41094

SWIGINTERN VALUE _wrap___transpose_times__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___transpose_times____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___transpose_times____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_wstring(argv[2], (std::wstring**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___transpose_times____SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___transpose_times____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__transpose_times__", 
    "    CNTK::FunctionPtr __transpose_times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, size_t outputRank, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __transpose_times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, size_t outputRank)\n"
    "    CNTK::FunctionPtr __transpose_times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __transpose_times__(CNTK::Variable const &leftOperand, CNTK::Variable const &rightOperand)\n");
  
  return Qnil;
}

.__uniform_initializer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25679

SWIGINTERN VALUE _wrap___uniform_initializer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap___uniform_initializer____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___uniform_initializer____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__uniform_initializer__", 
    "    CNTK::Dictionary __uniform_initializer__(double scale, unsigned long seed)\n"
    "    CNTK::Dictionary __uniform_initializer__(double scale)\n");
  
  return Qnil;
}

.unpooling(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 49235

SWIGINTERN VALUE _wrap___unpooling__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs;
  if (argc > 9) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            return _wrap___unpooling____SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            {
              // '1000' is the typecheck precedence code. It means: check after basic
              // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
              _v = NIL_P(rb_check_array_type(argv[4])) ? 0 : 1;
            }
            if (_v) {
              return _wrap___unpooling____SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            {
              // '1000' is the typecheck precedence code. It means: check after basic
              // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
              _v = NIL_P(rb_check_array_type(argv[4])) ? 0 : 1;
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector<bool,std::allocator< bool > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap___unpooling____SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            {
              // '1000' is the typecheck precedence code. It means: check after basic
              // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
              _v = NIL_P(rb_check_array_type(argv[4])) ? 0 : 1;
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector<bool,std::allocator< bool > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  return _wrap___unpooling____SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            {
              // '1000' is the typecheck precedence code. It means: check after basic
              // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
              _v = NIL_P(rb_check_array_type(argv[4])) ? 0 : 1;
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector<bool,std::allocator< bool > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  {
                    // '1000' is the typecheck precedence code. It means: check after basic
                    // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                    _v = NIL_P(rb_check_array_type(argv[7])) ? 0 : 1;
                  }
                  if (_v) {
                    return _wrap___unpooling____SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            // '1000' is the typecheck precedence code. It means: check after basic
            // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
            _v = NIL_P(rb_check_array_type(argv[3])) ? 0 : 1;
          }
          if (_v) {
            {
              // '1000' is the typecheck precedence code. It means: check after basic
              // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
              _v = NIL_P(rb_check_array_type(argv[4])) ? 0 : 1;
            }
            if (_v) {
              int res = swig::asptr(argv[5], (std::vector<bool,std::allocator< bool > >**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  // '1000' is the typecheck precedence code. It means: check after basic
                  // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                  _v = NIL_P(rb_check_array_type(argv[6])) ? 0 : 1;
                }
                if (_v) {
                  {
                    // '1000' is the typecheck precedence code. It means: check after basic
                    // types, but before arrays. See: http://www.swig.org/Doc3.0/Typemaps.html#Typemaps_overloading
                    _v = NIL_P(rb_check_array_type(argv[7])) ? 0 : 1;
                  }
                  if (_v) {
                    int res = SWIG_AsPtr_std_wstring(argv[8], (std::wstring**)(0));
                    _v = SWIG_CheckState(res);
                    if (_v) {
                      return _wrap___unpooling____SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "__unpooling__", 
    "    CNTK::FunctionPtr __unpooling__(CNTK::Variable const &operand, CNTK::Variable const &poolingInput, CNTK::PoolingType UnpoolingType, CNTK::NDShape const &UnpoolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad, CNTK::NDShape const &upperPad, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __unpooling__(CNTK::Variable const &operand, CNTK::Variable const &poolingInput, CNTK::PoolingType UnpoolingType, CNTK::NDShape const &UnpoolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad, CNTK::NDShape const &upperPad)\n"
    "    CNTK::FunctionPtr __unpooling__(CNTK::Variable const &operand, CNTK::Variable const &poolingInput, CNTK::PoolingType UnpoolingType, CNTK::NDShape const &UnpoolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding, CNTK::NDShape const &lowerPad)\n"
    "    CNTK::FunctionPtr __unpooling__(CNTK::Variable const &operand, CNTK::Variable const &poolingInput, CNTK::PoolingType UnpoolingType, CNTK::NDShape const &UnpoolingWindowShape, CNTK::NDShape const &strides, std::vector< bool,std::allocator< bool > > const &autoPadding)\n"
    "    CNTK::FunctionPtr __unpooling__(CNTK::Variable const &operand, CNTK::Variable const &poolingInput, CNTK::PoolingType UnpoolingType, CNTK::NDShape const &UnpoolingWindowShape, CNTK::NDShape const &strides)\n"
    "    CNTK::FunctionPtr __unpooling__(CNTK::Variable const &operand, CNTK::Variable const &poolingInput, CNTK::PoolingType UnpoolingType, CNTK::NDShape const &UnpoolingWindowShape)\n");
  
  return Qnil;
}

.__variable_kind_name__(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 23976

SWIGINTERN VALUE
_wrap___variable_kind_name__(int argc, VALUE *argv, VALUE self) {
  CNTK::VariableKind arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  wchar_t *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "CNTK::VariableKind","CNTK::VariableKindName", 1, argv[0] ));
  } 
  arg1 = static_cast< CNTK::VariableKind >(val1);
  {
    try {
      result = (wchar_t *)CNTK::VariableKindName(arg1); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_FromWCharPtr((const wchar_t *)result);
  return vresult;
fail:
  return Qnil;
}

.__weighted_binary_cross_entropy__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 41705

SWIGINTERN VALUE _wrap___weighted_binary_cross_entropy__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap___weighted_binary_cross_entropy____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_wstring(argv[3], (std::wstring**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap___weighted_binary_cross_entropy____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__weighted_binary_cross_entropy__", 
    "    CNTK::FunctionPtr __weighted_binary_cross_entropy__(CNTK::Variable const &prediction, CNTK::Variable const &targets, CNTK::Variable const &weights, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __weighted_binary_cross_entropy__(CNTK::Variable const &prediction, CNTK::Variable const &targets, CNTK::Variable const &weights)\n");
  
  return Qnil;
}

.where(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 53006

SWIGINTERN VALUE _wrap___where__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___where____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___where____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__where__", 
    "    CNTK::FunctionPtr __where__(CNTK::Variable const &condition, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __where__(CNTK::Variable const &condition)\n");
  
  return Qnil;
}

.__xavier_initializer__(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 26271

SWIGINTERN VALUE _wrap___xavier_initializer__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs;
  if (argc > 4) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap___xavier_initializer____SWIG_4(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap___xavier_initializer____SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___xavier_initializer____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap___xavier_initializer____SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_long(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap___xavier_initializer____SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__xavier_initializer__", 
    "    CNTK::Dictionary __xavier_initializer__(double scale, int outputRank, int filterRank, unsigned long seed)\n"
    "    CNTK::Dictionary __xavier_initializer__(double scale, int outputRank, int filterRank)\n"
    "    CNTK::Dictionary __xavier_initializer__(double scale, int outputRank)\n"
    "    CNTK::Dictionary __xavier_initializer__(double scale)\n"
    "    CNTK::Dictionary __xavier_initializer__()\n");
  
  return Qnil;
}

.abs(*args, self) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 36379

SWIGINTERN VALUE _wrap___abs__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[2];
  int ii;
  
  argc = nargs;
  if (argc > 2) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap___abs____SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_CNTK__Variable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_wstring(argv[1], (std::wstring**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___abs____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__abs__", 
    "    CNTK::FunctionPtr __abs__(CNTK::Variable const &operand, std::wstring const &name)\n"
    "    CNTK::FunctionPtr __abs__(CNTK::Variable const &operand)\n");
  
  return Qnil;
}

.create_composite_minibatch_source(dict) ⇒ `Object`

# File 'lib/cntk/io.rb', line 3

def self.create_composite_minibatch_source(dict)
  if dict.respond_to?(:to_hash)
    h = {}
    dict.to_hash.each_pair{|k, v|
      k = k.to_s if k.is_a?(Symbol)
      h[k] = v
    }
    des = h["deserializers"]
    unless des.respond_to?(:to_ary)
      h["deserializers"] = [des]
    end
    dict = Dictionary.create(h)
  end
  CNTK.__create_composite_minibatch_source__(dict)
end

.default_unit_gain_value(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 55426

SWIGINTERN VALUE
_wrap_default_unit_gain_value(int argc, VALUE *argv, VALUE self) {
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  {
    try {
      result = (bool)CNTK::DefaultUnitGainValue(); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

.DefaultParamInitFilterRank ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25477

SWIGINTERN VALUE
_wrap_DefaultParamInitFilterRank_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(CNTK::DefaultParamInitFilterRank));
  return _val;
}

.DefaultParamInitOutputRank ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25468

SWIGINTERN VALUE
_wrap_DefaultParamInitOutputRank_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(CNTK::DefaultParamInitOutputRank));
  return _val;
}

.DefaultParamInitScale ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25459

SWIGINTERN VALUE
_wrap_DefaultParamInitScale_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(CNTK::DefaultParamInitScale));
  return _val;
}

.DefaultVarianceMomentum ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 56831

SWIGINTERN VALUE
_wrap_DefaultVarianceMomentum_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&CNTK::DefaultVarianceMomentum), SWIGTYPE_p_CNTK__MomentumSchedule,  0 );
  return _val;
}

.DefaultVarianceMomentum=(_val) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 56840

SWIGINTERN VALUE
_wrap_DefaultVarianceMomentum_set(VALUE self, VALUE _val) {
  {
    void *argp = 0;
    int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_CNTK__MomentumSchedule,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""CNTK::DefaultVarianceMomentum""' of type '""CNTK::MomentumSchedule""'");
    }
    if (!argp) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""CNTK::DefaultVarianceMomentum""' of type '""CNTK::MomentumSchedule""'");
    } else {
      CNTK::DefaultVarianceMomentum = *(reinterpret_cast< CNTK::MomentumSchedule * >(argp));
    }
  }
  return _val;
fail:
  return Qnil;
}

.SentinelValueForAutoSelectRandomSeed ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25441

SWIGINTERN VALUE
_wrap_SentinelValueForAutoSelectRandomSeed_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(CNTK::SentinelValueForAutoSelectRandomSeed));
  return _val;
}

.SentinelValueForInferParamInitRank ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 25450

SWIGINTERN VALUE
_wrap_SentinelValueForInferParamInitRank_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_int(static_cast< int >(CNTK::SentinelValueForInferParamInitRank));
  return _val;
}

.set_default_unit_gain_value(*args) ⇒ `Object`

# File 'ext/cntk/cntk_wrap.cxx', line 55458

SWIGINTERN VALUE
_wrap_set_default_unit_gain_value(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","CNTK::SetDefaultUnitGainValue", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  {
    try {
      CNTK::SetDefaultUnitGainValue(arg1); 
    }
    catch (const std::runtime_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (const std::invalid_argument &e) {
      SWIG_exception(SWIG_ValueError,e.what()); 
    }
    catch (const std::logic_error &e) {
      SWIG_exception(SWIG_RuntimeError,e.what()); 
    }
    catch (...) {
      SWIG_exception(SWIG_UnknownError,"Runtime exception"); 
    }
  }
  return Qnil;
fail:
  return Qnil;
}

Module: CNTK

Defined Under Namespace

Constant Summary collapse

Class Method Summary collapse

Class Method Details

.__adam_learner__(*args, self) ⇒ Object

.__alias__(*args, self) ⇒ Object

.__as_block__(*args, self) ⇒ Object

.__batch_normalization__(*args, self) ⇒ Object

.__bilinear_initializer__(*args) ⇒ Object

.__binary_cross_entropy__(*args, self) ⇒ Object

.__broadcast_as__(*args, self) ⇒ Object

.__ceil__(*args, self) ⇒ Object

.__classification_error__(*args, self) ⇒ Object

.__clip__(*args, self) ⇒ Object

.__combine__(*args, self) ⇒ Object

.__compute_input_per_dim_means_and_inv_std_devs__(*args, self) ⇒ Object

.__constant_initializer__(*args, self) ⇒ Object

.__convolution__(*args, self) ⇒ Object

.__cos__(*args, self) ⇒ Object

.__cosine_distance__(*args, self) ⇒ Object

.__create_basic_training_session__(*args, self) ⇒ Object

.__create_composite_minibatch_source__(*args) ⇒ Object

.__create_trainer__(*args, self) ⇒ Object

.__cross_entropy_with_softmax__(*args, self) ⇒ Object

.__data_type_name__(*args) ⇒ Object

.__data_type_size__(*args) ⇒ Object

.__dropout__(*args, self) ⇒ Object

.__edit_distance_error__(*args, self) ⇒ Object

.__element_divide__(*args, self) ⇒ Object

.__element_select__(*args, self) ⇒ Object

.__element_times__(*args, self) ⇒ Object

.__equal__(*args, self) ⇒ Object

.__exp__(*args, self) ⇒ Object

.__first__(*args, self) ⇒ Object

.__floor__(*args, self) ⇒ Object

.__future_value__(*args, self) ⇒ Object

.__gather__(*args, self) ⇒ Object

.__get_max_num_cputhreads__(*args) ⇒ Object

.__glorot_normal_initializer__(*args, self) ⇒ Object

.__glorot_uniform_initializer__(*args, self) ⇒ Object

.__greater__(*args, self) ⇒ Object

.__greater_equal__(*args, self) ⇒ Object

.__hardmax__(*args, self) ⇒ Object

.__he_normal_initializer__(*args, self) ⇒ Object

.__he_uniform_initializer__(*args, self) ⇒ Object

.__input_variable__(*args, self) ⇒ Object

.__is_first__(*args, self) ⇒ Object

.__is_last__(*args, self) ⇒ Object

.__lambda_rank__(*args, self) ⇒ Object

.__last__(*args, self) ⇒ Object

.__less__(*args, self) ⇒ Object

.__less_equal__(*args, self) ⇒ Object

.__log__(*args, self) ⇒ Object

.__log_add_exp__(*args, self) ⇒ Object

.__minus__(*args, self) ⇒ Object

.__momentum_sgdlearner__(*args, self) ⇒ Object

.__mpicommunicator__(*args) ⇒ Object

.__ndcgat1__(*args, self) ⇒ Object

.__negate__(*args, self) ⇒ Object

.__nesterov_learner__(*args, self) ⇒ Object

.__normal_initializer__(*args, self) ⇒ Object

.__not_equal__(*args, self) ⇒ Object

.__optimized_rnnstack__(*args, self) ⇒ Object

.__output_variable__(*args) ⇒ Object

.__past_value__(*args, self) ⇒ Object

.__per_dim_mean_variance_normalize__(*args, self) ⇒ Object

.__placeholder_variable__(*args) ⇒ Object

.__plus__(*args, self) ⇒ Object

.__pooling__(*args, self) ⇒ Object

.__quantized_mpicommunicator__(*args) ⇒ Object

.__random_initializer_with_rank__(*args) ⇒ Object

.__random_sample__(*args) ⇒ Object

.__random_sample_inclusion_frequency__(*args) ⇒ Object

.__re_lu__(*args, self) ⇒ Object

.__reciprocal__(*args, self) ⇒ Object

.__reduce_log_sum__(*args, self) ⇒ Object

.__reduce_max__(*args, self) ⇒ Object

.__reduce_mean__(*args, self) ⇒ Object

.__reduce_min__(*args, self) ⇒ Object