Class: CNTK::StdVectorPairVariableVariable

Inherits:
Object
  • Object
show all
Defined in:
ext/cntk/cntk_wrap.cxx

Instance Method Summary collapse

Constructor Details

#initialize(*args, self) ⇒ Object 



9925
9926
9927
9928
9929
9930
9931
9932
9933
9934
9935
9936
9937
9938
9939
9940
9941
9942
9943
9944
9945
9946
9947
9948
9949
9950
9951
9952
9953
9954
9955
9956
9957
9958
9959
9960
9961
9962
9963
9964
9965
9966
9967
9968
9969
9970
9971
9972
9973
9974
9975
9976
9977
9978
9979
9980
 
# File 'ext/cntk/cntk_wrap.cxx', line 9925

SWIGINTERN VALUE _wrap_new_StdVectorPairVariableVariable(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 == 0) {
    return _wrap_new_StdVectorPairVariableVariable__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StdVectorPairVariableVariable__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StdVectorPairVariableVariable__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StdVectorPairVariableVariable__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StdVectorPairVariableVariable.new", 
    "    StdVectorPairVariableVariable.new()\n"
    "    StdVectorPairVariableVariable.new(std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const &)\n"
    "    StdVectorPairVariableVariable.new(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type size)\n"
    "    StdVectorPairVariableVariable.new(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type size, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &value)\n");
  
  return Qnil;
}

Instance Method Details

#[](*args, self) ⇒ Object

call-seq:

[](i, length) -> VALUE
[](i) -> VALUE
[](i) -> VALUE

Element accessor/slicing.



8801
8802
8803
8804
8805
8806
8807
8808
8809
8810
8811
8812
8813
8814
8815
8816
8817
8818
8819
8820
8821
8822
8823
8824
8825
8826
8827
8828
8829
8830
8831
8832
8833
8834
8835
8836
8837
8838
8839
8840
8841
8842
8843
8844
8845
8846
8847
8848
8849
8850
8851
8852
8853
8854
8855
8856
8857
8858
8859
8860
8861
8862
8863
8864
8865
 
# File 'ext/cntk/cntk_wrap.cxx', line 8801

SWIGINTERN VALUE _wrap_StdVectorPairVariableVariable___getitem__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (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_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StdVectorPairVariableVariable___getitem____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      _v = (argv[1] != 0);
      if (_v) {
        return _wrap_StdVectorPairVariableVariable___getitem____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (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_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StdVectorPairVariableVariable___getitem____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "__getitem__", 
    "    VALUE __getitem__(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type i, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type length)\n"
    "    VALUE __getitem__(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type i)\n"
    "    VALUE __getitem__(VALUE i)\n");
  
  return Qnil;
}

#[]=(*args, self) ⇒ Object

call-seq:

[]=(i, x) -> VALUE
[]=(i, length, v) -> VALUE

Element setter/slicing.



8991
8992
8993
8994
8995
8996
8997
8998
8999
9000
9001
9002
9003
9004
9005
9006
9007
9008
9009
9010
9011
9012
9013
9014
9015
9016
9017
9018
9019
9020
9021
9022
9023
9024
9025
9026
9027
9028
9029
9030
9031
9032
9033
9034
9035
9036
9037
9038
9039
9040
9041
9042
9043
9044
9045
9046
9047
9048
9049
9050
9051
9052
 
# File 'ext/cntk/cntk_wrap.cxx', line 8991

SWIGINTERN VALUE _wrap_StdVectorPairVariableVariable___setitem__(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (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_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StdVectorPairVariableVariable___setitem____SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (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_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StdVectorPairVariableVariable___setitem____SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "__setitem__", 
    "    VALUE __setitem__(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type i, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &x)\n"
    "    VALUE __setitem__(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type i, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type length, std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > const &v)\n");
  
  return Qnil;
}

#__delete2__(*args) ⇒ Object 



8530
8531
8532
8533
8534
8535
8536
8537
8538
8539
8540
8541
8542
8543
8544
8545
8546
8547
8548
8549
8550
8551
8552
8553
8554
8555
8556
8557
8558
8559
8560
8561
8562
 
# File 'ext/cntk/cntk_wrap.cxx', line 8530

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable___delete2__(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  VALUE 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(self, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","__delete2__", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &","__delete2__", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &","__delete2__", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type * >(argp2);
  result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg____delete2__(arg1,(std::pair< CNTK::Variable,CNTK::Variable > const &)*arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#assign(*args) ⇒ Object

call-seq:

assign(n, x)

Assign a new StdVectorPairVariableVariable or portion of it.



10058
10059
10060
10061
10062
10063
10064
10065
10066
10067
10068
10069
10070
10071
10072
10073
10074
10075
10076
10077
10078
10079
10080
10081
10082
10083
10084
10085
10086
10087
10088
10089
10090
10091
10092
10093
10094
10095
 
# File 'ext/cntk/cntk_wrap.cxx', line 10058

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_assign(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type arg2 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type","assign", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &","assign", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &","assign", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}

#at(*args) ⇒ Object

call-seq:

at(i) -> VALUE

Return element at a certain index.



8648
8649
8650
8651
8652
8653
8654
8655
8656
8657
8658
8659
8660
8661
8662
8663
8664
8665
8666
8667
8668
8669
8670
8671
8672
8673
8674
8675
8676
8677
 
# File 'ext/cntk/cntk_wrap.cxx', line 8648

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_at(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  VALUE 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(self, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *","at", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type","at", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type >(val2);
  result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__at((std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *)arg1,arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#back(*args) ⇒ Object

call-seq:

back -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &

Return the last element in StdVectorPairVariableVariable.



10025
10026
10027
10028
10029
10030
10031
10032
10033
10034
10035
10036
10037
10038
10039
10040
10041
10042
10043
10044
10045
10046
 
# File 'ext/cntk/cntk_wrap.cxx', line 10025

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_back(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type *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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *","back", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type *) &((std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *)arg1)->back();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#begin(*args) ⇒ Object

call-seq:

begin -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator

Return an iterator to the beginning of the StdVectorPairVariableVariable.



9473
9474
9475
9476
9477
9478
9479
9480
9481
9482
9483
9484
9485
9486
9487
9488
9489
9490
9491
9492
9493
9494
9495
9496
 
# File 'ext/cntk/cntk_wrap.cxx', line 9473

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_begin(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (arg1)->begin();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#capacity(*args) ⇒ Object

call-seq:

capacity -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type

Reserved capacity of the StdVectorPairVariableVariable.



10452
10453
10454
10455
10456
10457
10458
10459
10460
10461
10462
10463
10464
10465
10466
10467
10468
10469
10470
10471
10472
10473
 
# File 'ext/cntk/cntk_wrap.cxx', line 10452

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_capacity(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *","capacity", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = ((std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *)arg1)->capacity();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#clear(*args) ⇒ Object

call-seq:

clear

Clear StdVectorPairVariableVariable contents.



9613
9614
9615
9616
9617
9618
9619
9620
9621
9622
9623
9624
9625
9626
9627
9628
9629
9630
9631
 
# File 'ext/cntk/cntk_wrap.cxx', line 9613

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_clear(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}

#delete_at(*args) ⇒ Object

call-seq:

delete_at(i) -> VALUE

Delete an element at a certain index.



8607
8608
8609
8610
8611
8612
8613
8614
8615
8616
8617
8618
8619
8620
8621
8622
8623
8624
8625
8626
8627
8628
8629
8630
8631
8632
8633
8634
8635
8636
 
# File 'ext/cntk/cntk_wrap.cxx', line 8607

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_delete_at(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  VALUE 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(self, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","delete_at", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type","delete_at", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type >(val2);
  result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__delete_at(arg1,arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#dup(*args) ⇒ Object

call-seq:

dup -> StdVectorPairVariableVariable

Create a duplicate of the class and unfreeze it if needed.



8319
8320
8321
8322
8323
8324
8325
8326
8327
8328
8329
8330
8331
8332
8333
8334
8335
8336
8337
8338
8339
8340
 
# File 'ext/cntk/cntk_wrap.cxx', line 8319

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_dup(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","dup", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__dup(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#each(*args) ⇒ Object

call-seq:

each -> StdVectorPairVariableVariable

Iterate thru each element in the StdVectorPairVariableVariable. A block must be provided.



8506
8507
8508
8509
8510
8511
8512
8513
8514
8515
8516
8517
8518
8519
8520
8521
8522
8523
8524
8525
8526
8527
 
# File 'ext/cntk/cntk_wrap.cxx', line 8506

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_each(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","each", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__each(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#empty?(*args) ⇒ Boolean

call-seq:

empty? -> bool

Check if the StdVectorPairVariableVariable is empty or not.

Returns:

  • (Boolean) 


9375
9376
9377
9378
9379
9380
9381
9382
9383
9384
9385
9386
9387
9388
9389
9390
9391
9392
9393
9394
9395
9396
 
# File 'ext/cntk/cntk_wrap.cxx', line 9375

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_emptyq___(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *","empty", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (bool)((std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *)arg1)->empty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}

#end(*args) ⇒ Object

call-seq:

end -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator

Return an iterator to past the end of the StdVectorPairVariableVariable.



9508
9509
9510
9511
9512
9513
9514
9515
9516
9517
9518
9519
9520
9521
9522
9523
9524
9525
9526
9527
9528
9529
9530
9531
 
# File 'ext/cntk/cntk_wrap.cxx', line 9508

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_end(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (arg1)->end();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#erase(*args, self) ⇒ Object

call-seq:

erase(pos) -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator
erase(first, last) -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator

Delete a portion of the StdVectorPairVariableVariable.



9824
9825
9826
9827
9828
9829
9830
9831
9832
9833
9834
9835
9836
9837
9838
9839
9840
9841
9842
9843
9844
9845
9846
9847
9848
9849
9850
9851
9852
9853
9854
9855
9856
9857
9858
9859
9860
9861
9862
9863
9864
9865
9866
9867
9868
9869
9870
9871
9872
9873
 
# File 'ext/cntk/cntk_wrap.cxx', line 9824

SWIGINTERN VALUE _wrap_StdVectorPairVariableVariable_erase(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::ConstIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_StdVectorPairVariableVariable_erase__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::ConstIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::ConstIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_StdVectorPairVariableVariable_erase__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "erase", 
    "    std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator erase(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator pos)\n"
    "    std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator erase(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator first, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator last)\n");
  
  return Qnil;
}

#front(*args) ⇒ Object

call-seq:

front -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &

Return the first element in StdVectorPairVariableVariable.



9992
9993
9994
9995
9996
9997
9998
9999
10000
10001
10002
10003
10004
10005
10006
10007
10008
10009
10010
10011
10012
10013
 
# File 'ext/cntk/cntk_wrap.cxx', line 9992

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_front(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type *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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *","front", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type *) &((std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *)arg1)->front();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#get_allocator(*args) ⇒ Object 



9634
9635
9636
9637
9638
9639
9640
9641
9642
9643
9644
9645
9646
9647
9648
9649
9650
9651
9652
9653
9654
9655
 
# File 'ext/cntk/cntk_wrap.cxx', line 9634

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_get_allocator(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *","get_allocator", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = ((std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *)arg1)->get_allocator();
  vresult = SWIG_NewPointerObj((new std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::allocator_type(static_cast< const std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#insert(*args, self) ⇒ Object

call-seq:

insert(pos, argc) -> StdVectorPairVariableVariable
insert(pos, x) -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator
insert(pos, n, x)

Insert one or more new elements in the StdVectorPairVariableVariable.



10318
10319
10320
10321
10322
10323
10324
10325
10326
10327
10328
10329
10330
10331
10332
10333
10334
10335
10336
10337
10338
10339
10340
10341
10342
10343
10344
10345
10346
10347
10348
10349
10350
10351
10352
10353
10354
10355
10356
10357
10358
10359
10360
10361
10362
10363
10364
10365
10366
10367
10368
10369
10370
10371
10372
10373
10374
10375
10376
10377
10378
10379
10380
10381
10382
10383
10384
10385
10386
10387
10388
10389
10390
10391
10392
10393
10394
10395
10396
10397
10398
10399
10400
10401
10402
 
# File 'ext/cntk/cntk_wrap.cxx', line 10318

SWIGINTERN VALUE _wrap_StdVectorPairVariableVariable_insert(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[5];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 5) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::ConstIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StdVectorPairVariableVariable_insert__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (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_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_StdVectorPairVariableVariable_insert__SWIG_0(nargs, args, self);
          }
          return _wrap_StdVectorPairVariableVariable_insert__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::ConstIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::Iterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator > *>(iter) != 0));
      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_std__pairT_CNTK__Variable_CNTK__Variable_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StdVectorPairVariableVariable_insert__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "insert", 
    "    std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > insert(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type pos, int argc, VALUE *argv, ...)\n"
    "    std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator insert(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator pos, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &x)\n"
    "    void insert(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::iterator pos, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type n, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &x)\n");
  
  return Qnil;
}

#inspect(*args) ⇒ Object

call-seq:

inspect -> VALUE

Inspect class and its contents.



8352
8353
8354
8355
8356
8357
8358
8359
8360
8361
8362
8363
8364
8365
8366
8367
8368
8369
8370
8371
8372
8373
 
# File 'ext/cntk/cntk_wrap.cxx', line 8352

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_inspect(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","inspect", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__inspect(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#pop(*args) ⇒ Object

call-seq:

pop -> VALUE

Remove and return element at the end of the StdVectorPairVariableVariable.



9097
9098
9099
9100
9101
9102
9103
9104
9105
9106
9107
9108
9109
9110
9111
9112
9113
9114
9115
9116
9117
9118
 
# File 'ext/cntk/cntk_wrap.cxx', line 9097

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_pop(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","pop", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__pop(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#push(*args) ⇒ Object Also known as: <<

call-seq:

push(e) -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const

Add an element at the end of the StdVectorPairVariableVariable.



9130
9131
9132
9133
9134
9135
9136
9137
9138
9139
9140
9141
9142
9143
9144
9145
9146
9147
9148
9149
9150
9151
9152
9153
9154
9155
9156
9157
9158
9159
9160
9161
9162
 
# File 'ext/cntk/cntk_wrap.cxx', line 9130

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_push(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< CNTK::Variable,CNTK::Variable > > 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(self, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","push", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &","push", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &","push", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type * >(argp2);
  result = std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__push(arg1,(std::pair< CNTK::Variable,CNTK::Variable > const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type(static_cast< const std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type& >(result))), SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#rbegin(*args) ⇒ Object

call-seq:

rbegin -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::reverse_iterator

Return a reverse iterator to the beginning (the end) of the StdVectorPairVariableVariable.



9543
9544
9545
9546
9547
9548
9549
9550
9551
9552
9553
9554
9555
9556
9557
9558
9559
9560
9561
9562
9563
9564
9565
9566
 
# File 'ext/cntk/cntk_wrap.cxx', line 9543

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_rbegin(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::reverse_iterator 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","rbegin", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (arg1)->rbegin();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::reverse_iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#reject(*args) ⇒ Object

call-seq:

reject -> StdVectorPairVariableVariable

Iterate thru each element in the StdVectorPairVariableVariable and reject those that fail a condition returning a new StdVectorPairVariableVariable. A block must be provided.



9174
9175
9176
9177
9178
9179
9180
9181
9182
9183
9184
9185
9186
9187
9188
9189
9190
9191
9192
9193
9194
9195
 
# File 'ext/cntk/cntk_wrap.cxx', line 9174

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_reject(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","reject", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__reject(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#reject!(*args) ⇒ Object Also known as: delete_if

call-seq:

reject! -> StdVectorPairVariableVariable

Iterate thru each element in the StdVectorPairVariableVariable and reject those that fail a condition. A block must be provided. StdVectorPairVariableVariable is modified in place.



9064
9065
9066
9067
9068
9069
9070
9071
9072
9073
9074
9075
9076
9077
9078
9079
9080
9081
9082
9083
9084
9085
 
# File 'ext/cntk/cntk_wrap.cxx', line 9064

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_rejectN___(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","reject_bang", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__reject_bang(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}

#rend(*args) ⇒ Object

call-seq:

rend -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::reverse_iterator

Return a reverse iterator to past the end (past the beginning) of the StdVectorPairVariableVariable.



9578
9579
9580
9581
9582
9583
9584
9585
9586
9587
9588
9589
9590
9591
9592
9593
9594
9595
9596
9597
9598
9599
9600
9601
 
# File 'ext/cntk/cntk_wrap.cxx', line 9578

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_rend(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::reverse_iterator 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","rend", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (arg1)->rend();
  vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::reverse_iterator & >(result),
      self),
    swig::Iterator::descriptor(),SWIG_POINTER_OWN);
  return vresult;
fail:
  return Qnil;
}

#reserve(*args) ⇒ Object

call-seq:

reserve(n)

Reserve memory in the StdVectorPairVariableVariable for a number of elements.



10414
10415
10416
10417
10418
10419
10420
10421
10422
10423
10424
10425
10426
10427
10428
10429
10430
10431
10432
10433
10434
10435
10436
10437
10438
10439
10440
 
# File 'ext/cntk/cntk_wrap.cxx', line 10414

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_reserve(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","reserve", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type","reserve", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type >(val2);
  (arg1)->reserve(arg2);
  return Qnil;
fail:
  return Qnil;
}

#resize(*args, self) ⇒ Object

call-seq:

resize(new_size)
resize(new_size, x)

Resize the size of the StdVectorPairVariableVariable.



10148
10149
10150
10151
10152
10153
10154
10155
10156
10157
10158
10159
10160
10161
10162
10163
10164
10165
10166
10167
10168
10169
10170
10171
10172
10173
10174
10175
10176
10177
10178
10179
10180
10181
10182
10183
10184
10185
10186
10187
10188
10189
10190
10191
10192
10193
10194
10195
10196
10197
10198
10199
 
# File 'ext/cntk/cntk_wrap.cxx', line 10148

SWIGINTERN VALUE _wrap_StdVectorPairVariableVariable_resize(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[4];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 4) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (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_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StdVectorPairVariableVariable_resize__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (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_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__pairT_CNTK__Variable_CNTK__Variable_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StdVectorPairVariableVariable_resize__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StdVectorPairVariableVariable.resize", 
    "    void StdVectorPairVariableVariable.resize(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type new_size)\n"
    "    void StdVectorPairVariableVariable.resize(std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type new_size, std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::value_type const &x)\n");
  
  return Qnil;
}

#select(*args) ⇒ Object

call-seq:

select -> StdVectorPairVariableVariable

Iterate thru each element in the StdVectorPairVariableVariable and select those that match a condition. A block must be provided.



8574
8575
8576
8577
8578
8579
8580
8581
8582
8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
8593
8594
8595
 
# File 'ext/cntk/cntk_wrap.cxx', line 8574

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_select(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","select", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__select(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}

#shift(*args) ⇒ Object

call-seq:

shift -> VALUE

Remove and return element at the beginning of the StdVectorPairVariableVariable.



9207
9208
9209
9210
9211
9212
9213
9214
9215
9216
9217
9218
9219
9220
9221
9222
9223
9224
9225
9226
9227
9228
 
# File 'ext/cntk/cntk_wrap.cxx', line 9207

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_shift(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","shift", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__shift(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#size(*args) ⇒ Object

call-seq:

size -> std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type

Size or Length of the StdVectorPairVariableVariable.



9408
9409
9410
9411
9412
9413
9414
9415
9416
9417
9418
9419
9420
9421
9422
9423
9424
9425
9426
9427
9428
9429
 
# File 'ext/cntk/cntk_wrap.cxx', line 9408

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_size(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::size_type 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = ((std::vector< std::pair< CNTK::Variable,CNTK::Variable > > const *)arg1)->size();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}

#slice(*args) ⇒ Object

call-seq:

slice(i, length) -> VALUE

Return a slice (portion of) the StdVectorPairVariableVariable.



8451
8452
8453
8454
8455
8456
8457
8458
8459
8460
8461
8462
8463
8464
8465
8466
8467
8468
8469
8470
8471
8472
8473
8474
8475
8476
8477
8478
8479
8480
8481
8482
8483
8484
8485
8486
8487
8488
8489
8490
8491
8492
8493
8494
 
# File 'ext/cntk/cntk_wrap.cxx', line 8451

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_slice(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type arg2 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","slice", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type","slice", 2, argv[0] ));
  } 
  arg2 = static_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type","slice", 3, argv[1] ));
  } 
  arg3 = static_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > >::difference_type >(val3);
  try {
    result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__slice(arg1,arg2,arg3);
  }
  catch(std::invalid_argument &_e) {
    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
  }
  
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#swap(*args) ⇒ Object 



9432
9433
9434
9435
9436
9437
9438
9439
9440
9441
9442
9443
9444
9445
9446
9447
9448
9449
9450
9451
9452
9453
9454
9455
9456
9457
9458
9459
9460
9461
 
# File 'ext/cntk/cntk_wrap.cxx', line 9432

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_swap(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}

#to_a(*args) ⇒ Object

call-seq:

to_a -> VALUE

Convert StdVectorPairVariableVariable to an Array.



8385
8386
8387
8388
8389
8390
8391
8392
8393
8394
8395
8396
8397
8398
8399
8400
8401
8402
8403
8404
8405
8406
 
# File 'ext/cntk/cntk_wrap.cxx', line 8385

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_to_a(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","to_a", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__to_a(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#to_s(*args) ⇒ Object

call-seq:

to_s -> VALUE

Convert class to a String representation.



8418
8419
8420
8421
8422
8423
8424
8425
8426
8427
8428
8429
8430
8431
8432
8433
8434
8435
8436
8437
8438
8439
 
# File 'ext/cntk/cntk_wrap.cxx', line 8418

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_to_s(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","to_s", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  result = (VALUE)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__to_s(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}

#unshift(*args) ⇒ Object

call-seq:

unshift(argc) -> StdVectorPairVariableVariable

Add one or more elements at the beginning of the StdVectorPairVariableVariable.



9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
9300
9301
9302
9303
9304
9305
9306
9307
9308
9309
9310
9311
9312
9313
9314
9315
9316
9317
9318
 
# File 'ext/cntk/cntk_wrap.cxx', line 9290

SWIGINTERN VALUE
_wrap_StdVectorPairVariableVariable_unshift(int argc, VALUE *argv, VALUE self) {
  std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *arg1 = (std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *) 0 ;
  int arg2 ;
  VALUE *arg3 = (VALUE *) 0 ;
  void *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *result = 0 ;
  VALUE vresult = Qnil;
  
  if (argc < 1) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::pair< CNTK::Variable,CNTK::Variable > > *","unshift", 1, self )); 
  }
  arg1 = reinterpret_cast< std::vector< std::pair< CNTK::Variable,CNTK::Variable > > * >(argp1);
  {
    arg2 = argc;
    arg3 = argv;
  }
  result = (std::vector< std::pair< CNTK::Variable,CNTK::Variable >,std::allocator< std::pair< CNTK::Variable,CNTK::Variable > > > *)std_vector_Sl_std_pair_Sl_CNTK_Variable_Sc_CNTK_Variable_Sg__Sg__unshift(arg1,arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__pairT_CNTK__Variable_CNTK__Variable_t_std__allocatorT_std__pairT_CNTK__Variable_CNTK__Variable_t_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}