Class: CNTK::Constant

Inherits:

((swig_class *) SWIGTYPE_p_CNTK__Variable->clientdata)->klass

• Object
• ((swig_class *) SWIGTYPE_p_CNTK__Variable->clientdata)->klass
• CNTK::Constant

Extended by:

VariableExtend

Defined in:

lib/cntk/variable.rb,
ext/cntk/cntk_wrap.cxx

Overview

< Variable

Class Method Summary

• .create(val, shape: nil, dtype: DataType_Float, device: DeviceDescriptor::use_default_device(), name: "") ⇒ Object
• .scalar(*args, self) ⇒ Object

Instance Method Summary

• #*(other) ⇒ Object
• #initialize(*args, self) ⇒ Object constructor
• #value(*args) ⇒ Object

Methods included from VariableExtend

create_from

Constructor Details

#initialize(*args, self) ⇒ Object

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

SWIGINTERN VALUE _wrap_new_Constant(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 == 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_new_Constant__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__NDArrayView_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Constant__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__NDArrayView_t, 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_new_Constant__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Constant__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    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_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__DeviceDescriptor, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Constant__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  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_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_CNTK__DeviceDescriptor, 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_new_Constant__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Constant.new", 
    "    Constant.new(CNTK::Variable const &variable)\n"
    "    Constant.new(CNTK::NDArrayViewPtr const &value, std::wstring const &name)\n"
    "    Constant.new(CNTK::NDArrayViewPtr const &value)\n"
    "    Constant.new(CNTK::NDShape const &shape, enum CNTK::DataType dataType, double initValue, CNTK::DeviceDescriptor const &device, std::wstring const &name)\n"
    "    Constant.new(CNTK::NDShape const &shape, enum CNTK::DataType dataType, double initValue, CNTK::DeviceDescriptor const &device)\n"
    "    Constant.new(CNTK::NDShape const &shape, enum CNTK::DataType dataType, double initValue)\n");
  
  return Qnil;
}

Class Method Details

.create(val, shape: nil, dtype: DataType_Float, device: DeviceDescriptor::use_default_device(), name: "") ⇒ Object

# File 'lib/cntk/variable.rb', line 88

def self.create(val, shape: nil, dtype: DataType_Float, device: DeviceDescriptor::use_default_device(), name: "")
  create_from(val, shape, dtype, device, name)
end

.scalar(*args, self) ⇒ Object

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

SWIGINTERN VALUE _wrap_Constant_scalar(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_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Constant_scalar__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _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_Constant_scalar__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Constant.scalar", 
    "    CNTK::Constant Constant.scalar(enum CNTK::DataType dataType, double value, ::CNTK::DeviceDescriptor const &device)\n"
    "    CNTK::Constant Constant.scalar(enum CNTK::DataType dataType, double value)\n");
  
  return Qnil;
}

Instance Method Details

#*(other) ⇒ Object

# File 'lib/cntk/variable.rb', line 92

def *(other)
  if is_scalar
    CNTK.__times__(other, self)
  else
    CNTK.__times__(self, other)
  end
end

#value(*args) ⇒ Object

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

SWIGINTERN VALUE
_wrap_Constant_value(int argc, VALUE *argv, VALUE self) {
  CNTK::Constant *arg1 = (CNTK::Constant *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CNTK::NDArrayViewPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CNTK__Constant, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::Constant *","Value", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::Constant * >(argp1);
  {
    try {
      result = (arg1)->Value(); 
    }
    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::NDArrayView > *smartresult = result ? new std::shared_ptr<  CNTK::NDArrayView >(result) : 0;
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_CNTK__NDArrayView_t, SWIG_POINTER_OWN);
  }
  return vresult;
fail:
  return Qnil;
}