Class: CNTK::MinibatchData

Inherits:
Object
  • Object
show all
Includes:
InspectUtil
Defined in:
lib/cntk/inspect.rb,
ext/cntk/cntk_wrap.cxx

Instance Method Summary collapse

Methods included from InspectUtil

#inspect_methods, #inspect_methods_p

Constructor Details

#initialize(*args, self) ⇒ Object 



60688
60689
60690
60691
60692
60693
60694
60695
60696
60697
60698
60699
60700
60701
60702
60703
60704
60705
60706
60707
60708
60709
60710
60711
60712
60713
60714
60715
60716
60717
60718
60719
60720
60721
60722
60723
60724
60725
60726
60727
60728
60729
60730
60731
60732
60733
60734
60735
60736
60737
60738
60739
60740
60741
60742
60743
60744
60745
60746
60747
60748
60749
60750
60751
60752
60753
60754
60755
60756
60757
60758
60759
60760
60761
60762
60763
60764
60765
60766
60767
60768
60769
60770
60771
60772
60773
60774
60775
60776
60777
60778
60779
 
# File 'ext/cntk/cntk_wrap.cxx', line 60688

SWIGINTERN VALUE _wrap_new_MinibatchData(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_new_MinibatchData__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Value_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MinibatchData__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Value_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MinibatchData__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Value_t, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MinibatchData__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__shared_ptrT_CNTK__Value_t, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MinibatchData__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MinibatchData.new", 
    "    MinibatchData.new()\n"
    "    MinibatchData.new(CNTK::ValuePtr value)\n"
    "    MinibatchData.new(CNTK::ValuePtr value, size_t numSamples, bool sweepEnd)\n"
    "    MinibatchData.new(CNTK::ValuePtr value, size_t numSamples)\n"
    "    MinibatchData.new(CNTK::ValuePtr value, size_t numSequences, size_t numSamples, bool sweepEnd)\n");
  
  return Qnil;
}

Instance Method Details

#data(*args) ⇒ Object 



60823
60824
60825
60826
60827
60828
60829
60830
60831
60832
60833
60834
60835
60836
60837
60838
60839
60840
60841
60842
60843
60844
60845
60846
60847
 
# File 'ext/cntk/cntk_wrap.cxx', line 60823

SWIGINTERN VALUE
_wrap_MinibatchData_data_get(int argc, VALUE *argv, VALUE self) {
  CNTK::MinibatchData *arg1 = (CNTK::MinibatchData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  CNTK::ValuePtr *result = 0 ;
  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__MinibatchData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::MinibatchData *","data", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::MinibatchData * >(argp1);
  result = (CNTK::ValuePtr *) & ((arg1)->data);
  {
    std::shared_ptr<  CNTK::Value > *smartresult = *result ? new std::shared_ptr<  CNTK::Value >(*result) : 0;
    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(smartresult), SWIGTYPE_p_std__shared_ptrT_CNTK__Value_t, SWIG_POINTER_OWN);
  }
  return vresult;
fail:
  return Qnil;
}

#data=(*args) ⇒ Object 



60782
60783
60784
60785
60786
60787
60788
60789
60790
60791
60792
60793
60794
60795
60796
60797
60798
60799
60800
60801
60802
60803
60804
60805
60806
60807
60808
60809
60810
60811
60812
60813
60814
60815
60816
60817
60818
60819
60820
 
# File 'ext/cntk/cntk_wrap.cxx', line 60782

SWIGINTERN VALUE
_wrap_MinibatchData_data_set(int argc, VALUE *argv, VALUE self) {
  CNTK::MinibatchData *arg1 = (CNTK::MinibatchData *) 0 ;
  CNTK::ValuePtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  CNTK::ValuePtr tempshared2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CNTK__MinibatchData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::MinibatchData *","data", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::MinibatchData * >(argp1);
  {
    swig_ruby_owntype newmem = {
      0, 0
    };
    res2 = SWIG_ConvertPtrAndOwn(argv[0], &argp2, SWIGTYPE_p_std__shared_ptrT_CNTK__Value_t,  0 , &newmem);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "CNTK::ValuePtr const &","data", 2, argv[0] ));
    }
    if (newmem.own & SWIG_CAST_NEW_MEMORY) {
      if (argp2) tempshared2 = *reinterpret_cast< CNTK::ValuePtr * >(argp2);
      delete reinterpret_cast< CNTK::ValuePtr * >(argp2);
      arg2 = &tempshared2;
    } else {
      arg2 = (argp2) ? reinterpret_cast< CNTK::ValuePtr * >(argp2) : &tempshared2;
    }
  }
  if (arg1) (arg1)->data = *arg2;
  return Qnil;
fail:
  return Qnil;
}

#inspect ⇒ Object 



52
53
54
 
# File 'lib/cntk/inspect.rb', line 52

def inspect
  inspect_methods([:data, :number_of_samples])
end

#number_of_samples(*args) ⇒ Object 



60932
60933
60934
60935
60936
60937
60938
60939
60940
60941
60942
60943
60944
60945
60946
60947
60948
60949
60950
60951
60952
60953
 
# File 'ext/cntk/cntk_wrap.cxx', line 60932

SWIGINTERN VALUE
_wrap_MinibatchData_number_of_samples_get(int argc, VALUE *argv, VALUE self) {
  CNTK::MinibatchData *arg1 = (CNTK::MinibatchData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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__MinibatchData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::MinibatchData *","numberOfSamples", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::MinibatchData * >(argp1);
  result =  ((arg1)->numberOfSamples);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#number_of_samples=(*args) ⇒ Object 



60903
60904
60905
60906
60907
60908
60909
60910
60911
60912
60913
60914
60915
60916
60917
60918
60919
60920
60921
60922
60923
60924
60925
60926
60927
60928
60929
 
# File 'ext/cntk/cntk_wrap.cxx', line 60903

SWIGINTERN VALUE
_wrap_MinibatchData_number_of_samples_set(int argc, VALUE *argv, VALUE self) {
  CNTK::MinibatchData *arg1 = (CNTK::MinibatchData *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CNTK__MinibatchData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::MinibatchData *","numberOfSamples", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::MinibatchData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","numberOfSamples", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->numberOfSamples = arg2;
  return Qnil;
fail:
  return Qnil;
}

#number_of_sequences(*args) ⇒ Object 



60879
60880
60881
60882
60883
60884
60885
60886
60887
60888
60889
60890
60891
60892
60893
60894
60895
60896
60897
60898
60899
60900
 
# File 'ext/cntk/cntk_wrap.cxx', line 60879

SWIGINTERN VALUE
_wrap_MinibatchData_number_of_sequences_get(int argc, VALUE *argv, VALUE self) {
  CNTK::MinibatchData *arg1 = (CNTK::MinibatchData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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__MinibatchData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::MinibatchData *","numberOfSequences", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::MinibatchData * >(argp1);
  result =  ((arg1)->numberOfSequences);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#number_of_sequences=(*args) ⇒ Object 



60850
60851
60852
60853
60854
60855
60856
60857
60858
60859
60860
60861
60862
60863
60864
60865
60866
60867
60868
60869
60870
60871
60872
60873
60874
60875
60876
 
# File 'ext/cntk/cntk_wrap.cxx', line 60850

SWIGINTERN VALUE
_wrap_MinibatchData_number_of_sequences_set(int argc, VALUE *argv, VALUE self) {
  CNTK::MinibatchData *arg1 = (CNTK::MinibatchData *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CNTK__MinibatchData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::MinibatchData *","numberOfSequences", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::MinibatchData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","numberOfSequences", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->numberOfSequences = arg2;
  return Qnil;
fail:
  return Qnil;
}

#sweep_end(*args) ⇒ Object 



60985
60986
60987
60988
60989
60990
60991
60992
60993
60994
60995
60996
60997
60998
60999
61000
61001
61002
61003
61004
61005
61006
 
# File 'ext/cntk/cntk_wrap.cxx', line 60985

SWIGINTERN VALUE
_wrap_MinibatchData_sweep_end_get(int argc, VALUE *argv, VALUE self) {
  CNTK::MinibatchData *arg1 = (CNTK::MinibatchData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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__MinibatchData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::MinibatchData *","sweepEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::MinibatchData * >(argp1);
  result = (bool) ((arg1)->sweepEnd);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#sweep_end=(*args) ⇒ Object 



60956
60957
60958
60959
60960
60961
60962
60963
60964
60965
60966
60967
60968
60969
60970
60971
60972
60973
60974
60975
60976
60977
60978
60979
60980
60981
60982
 
# File 'ext/cntk/cntk_wrap.cxx', line 60956

SWIGINTERN VALUE
_wrap_MinibatchData_sweep_end_set(int argc, VALUE *argv, VALUE self) {
  CNTK::MinibatchData *arg1 = (CNTK::MinibatchData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_CNTK__MinibatchData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "CNTK::MinibatchData *","sweepEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< CNTK::MinibatchData * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","sweepEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->sweepEnd = arg2;
  return Qnil;
fail:
  return Qnil;
}