Module: ZDD

Defined in:

ext/zdd_so/zdd_so.cpp

Class Method Summary

• .%(*args) ⇒ Object

  ##vsop_remainder##.

• .*(*args) ⇒ Object

  ##vsop_multiply##.

• .+(*args) ⇒ Object

  ##vsop_plus##.

• .+@ ⇒ Object

  ##vsop_plus_op##.

• .-(*args) ⇒ Object

  ##vsop_minus##.

• .-@ ⇒ Object

  ##vsop_minus_op##.

• ./(*args) ⇒ Object

  ##vsop_quotiment##.

• .<(*args) ⇒ Object

  ##vsop_lt##.

• .<=(*args) ⇒ Object

  ##vsop_le##.

• .==(*args) ⇒ Object

  ##vsop_eq##.

• .===(*args) ⇒ Object

  ##vsop_same##.

• .>(*args) ⇒ Object

  ##vsop_gt##.

• .>=(*args) ⇒ Object

  ##vsop_ge##.

• .coerce(*args) ⇒ Object

  強制変換用.

• .constant(*args) ⇒ Object

  ##vsop_constant##.

• .cost ⇒ Object

  ##vsop_print_value##.

• .count ⇒ Object

  ##vsop_print_count##.

• .csvout(*args) ⇒ Object

  ##vsop_csvout##.

• .delta(*args) ⇒ Object

  ##vsop_delta##.

• .density ⇒ Object

  ##vsop_print_density##.

• .diff?(*args) ⇒ Boolean

  ##vsop_diff##.

• .each ⇒ Object

  ##vsop_each##.

• .each_item ⇒ Object

  ##vsop_each_item##.

• .export(*args) ⇒ Object

  ##vsop_print_export##.

• .freqpatA(*args) ⇒ Object

  ##vsop_freqpatA##.

• .freqpatC(*args) ⇒ Object

  ##vsop_freqpatC##.

• .freqpatM(*args) ⇒ Object

  ##vsop_freqpatM##.

• .hashout ⇒ Object

  ##vsop_hashout##.

• .iif(*args) ⇒ Object

  ##vsop_iif##.

• .import(*args) ⇒ Object

  ##vsop_import##.

• .inspect ⇒ Object

  ##vsop_to_s##.

• .items ⇒ Object

  ##vsop_items##.

• .itemset(*args) ⇒ Object

  ##vsop_itemset##.

• .lcm(*args) ⇒ Object

  ##vsop_lcm##.

• .maxcost ⇒ Object

  ##vsop_print_maxcost##.

• .maxcover ⇒ Object

  ##vsop_print_maxcover##.

• .maxweight ⇒ Object

  ##vsop_maxval##.

• .meet(*args) ⇒ Object

  ##vsop_meet##.

• .mincost ⇒ Object

  ##vsop_print_mincost##.

• .mincover ⇒ Object

  ##vsop_print_mincover##.

• .minweight ⇒ Object

  ##vsop_minval##.

• .ne?(*args) ⇒ Boolean

  ##vsop_ne##.

• .partly ⇒ Object

  ##vsop_partly##.

• .permit(*args) ⇒ Object

  ##vsop_permit##.

• .permitsym(*args) ⇒ Object

  ##vsop_permitsym##.

• .restrict(*args) ⇒ Object

  ##vsop_restrict##.

• .same?(*args) ⇒ Boolean

  ##vsop_same##.

• .show(*args) ⇒ Object

  ##vsop_show##.

• .size ⇒ Object

  ##vsop_print_size##.

• .symbol(*args) ⇒ Object

  ##vsop_symbol##.

• .symgrp ⇒ Object

  ##vsop_symgrp##.

• .termsEQ(*args) ⇒ Object

  ##vsop_termsEQ##.

• .termsGE(*args) ⇒ Object

  ##vsop_termsGE##.

• .termsGT(*args) ⇒ Object

  ##vsop_termsGT##.

• .termsLE(*args) ⇒ Object

  ##vsop_termsLE##.

• .termsLT(*args) ⇒ Object

  ##vsop_termsLT##.

• .termsNE(*args) ⇒ Object

  ##vsop_termsNE##.

• .to_a ⇒ Object

  ##vsop_to_a##.

• .to_i ⇒ Object

  ##vsop_const_to_i##.

• .to_s ⇒ Object

  ##vsop_to_s##.

• .totalsize ⇒ Object

  ##vsop_print_totalsize##.

• .totalweight ⇒ Object

  ##vsop_totalval##.

Class Method Details

.%(*args) ⇒ Object

##vsop_remainder##

# File 'ext/zdd_so/zdd_so.cpp', line 1087

VALUE vsop_remainder(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      if(*ctoi_modc == 0)
      {
        yyerror("<WARNING> Divide by zero");
        *ctoi_moda = 0;
      }
      else *ctoi_moda = *ctoi_moda % *ctoi_modc;
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.*(*args) ⇒ Object

##vsop_multiply##

# File 'ext/zdd_so/zdd_so.cpp', line 1046

VALUE vsop_multiply(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = Product(*ctoi_moda, *ctoi_modc);
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.+(*args) ⇒ Object

##vsop_plus##

# File 'ext/zdd_so/zdd_so.cpp', line 862

VALUE vsop_plus(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin;
	      *ctoi_moda = *ctoi_moda + *ctoi_modc;
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.+@ ⇒ Object

##vsop_plus_op##

# File 'ext/zdd_so/zdd_so.cpp', line 849

VALUE vsop_plus_op(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	CtoI *ctoi_modb =new CtoI(*rmod->cmod);
	CtoI *ctoi_fin; 
	      ctoi_fin = ctoi_modb;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.-(*args) ⇒ Object

##vsop_minus##

# File 'ext/zdd_so/zdd_so.cpp', line 880

VALUE vsop_minus(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = *ctoi_moda - *ctoi_modc;
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.-@ ⇒ Object

##vsop_minus_op##

# File 'ext/zdd_so/zdd_so.cpp', line 835

VALUE vsop_minus_op(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	CtoI *ctoi_modb =new CtoI(*rmod->cmod);
	CtoI *ctoi_fin; 
	      *ctoi_modb = - *ctoi_modb;
      ctoi_fin = ctoi_modb;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

./(*args) ⇒ Object

##vsop_quotiment##

# File 'ext/zdd_so/zdd_so.cpp', line 1064

VALUE vsop_quotiment(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      if(*ctoi_modc == 0)
      {
        yyerror("<WARNING> Divide by zero");
        *ctoi_moda = 0;
      }
      else *ctoi_moda = *ctoi_moda / *ctoi_modc;
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.<(*args) ⇒ Object

##vsop_lt##

# File 'ext/zdd_so/zdd_so.cpp', line 989

VALUE vsop_lt(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = CtoI_LT(*ctoi_moda, *ctoi_modc);
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.<=(*args) ⇒ Object

##vsop_le##

# File 'ext/zdd_so/zdd_so.cpp', line 1007

VALUE vsop_le(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = CtoI_LE(*ctoi_moda, *ctoi_modc);
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.==(*args) ⇒ Object

##vsop_eq##

# File 'ext/zdd_so/zdd_so.cpp', line 917

VALUE vsop_eq(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = CtoI_EQ(*ctoi_moda, *ctoi_modc);
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.===(*args) ⇒ Object

##vsop_same##

# File 'ext/zdd_so/zdd_so.cpp', line 2741

VALUE vsop_same(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	
	CtoI *ctoi_modc = value2ctoi(v);
	if ( *rmod->cmod == *ctoi_modc){
		return Qtrue;
	} 
	else{
		return  Qfalse;
	}
}

.>(*args) ⇒ Object

##vsop_gt##

# File 'ext/zdd_so/zdd_so.cpp', line 953

VALUE vsop_gt(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = CtoI_GT(*ctoi_moda, *ctoi_modc);
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.>=(*args) ⇒ Object

##vsop_ge##

# File 'ext/zdd_so/zdd_so.cpp', line 971

VALUE vsop_ge(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = CtoI_GE(*ctoi_moda, *ctoi_modc);
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.coerce(*args) ⇒ Object

強制変換用

# File 'ext/zdd_so/zdd_so.cpp', line 3151

VALUE vsop_coerce(int argc, VALUE *argv, VALUE self){
	VALUE v;
	Vsop_Ruby* rmod=new Vsop_Ruby;
	rb_scan_args(argc, argv,"10",&v);
	rmod->cmod =value2ctoi(v);
	VALUE rtn_v = Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod);
	return rb_ary_new3(2,rtn_v,self);
}

.constant(*args) ⇒ Object

##vsop_constant##

# File 'ext/zdd_so/zdd_so.cpp', line 2532

VALUE vsop_constant(int argc, VALUE *argv, VALUE self)
{
	Vsop_Ruby* rmod=new Vsop_Ruby;
	VALUE v;

	//引数読み込み
	rb_scan_args(argc, argv,"10",&v);

	CtoI ctoitmp;
	//定数FIXNUM
	if(TYPE(v)==T_FIXNUM){
		rmod->cmod = int2ctoi(FIX2INT(v));
	}
	//定数BIGNUM
	else if(TYPE(v)==T_BIGNUM){
		rmod->cmod = int2ctoi(NUM2INT(v));
	}
	else{
		rb_raise(rb_eRuntimeError,"argument type error (arguments must be FIXNUM or BIGNUM)");
	}
	VALUE rtn = Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod);
	return rtn;
}

.cost ⇒ Object

##vsop_print_value##

# File 'ext/zdd_so/zdd_so.cpp', line 2837

VALUE vsop_print_value( VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	auto_ptr<CtoI> auto_p(new CtoI(*rmod->cmod));
	CtoI *ctoitmp = auto_p.get();
	
	if(OVF.Check()!= 0){
		rb_raise(rb_eRuntimeError,"Bit overflow occurred");
	}
	VALUE rtn = rb_float_new((float)Value(*ctoitmp)/power16);
	return rtn;
}

.count ⇒ Object

##vsop_print_count##

# File 'ext/zdd_so/zdd_so.cpp', line 2790

VALUE vsop_print_count( VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	auto_ptr<CtoI> auto_p(new CtoI(*rmod->cmod));
	CtoI *ctoitmp = auto_p.get();
	*ctoitmp = ctoitmp -> CountTerms();
	if(*ctoitmp == CtoI_Null())
	{
		*ctoitmp = 0;
		rb_raise(rb_eRuntimeError,"06Memory overflow");
	}
	int slen = ctoitmp->TopDigit() / 3 + 14;
	kgAutoPtr2<char> a_ptr;
	char *s;
	try{
		a_ptr.set(new char[slen]);
		s = a_ptr.get();
	}catch(...){
		rb_raise(rb_eRuntimeError,"memory allocation error");
	}
	ctoitmp -> StrNum10(s);
	VALUE rtn = rb_cstr_to_inum(s, 10, Qfalse);
	return rtn;
}

.csvout(*args) ⇒ Object

##vsop_csvout##

# File 'ext/zdd_so/zdd_so.cpp', line 1743

VALUE vsop_csvout(int argc, VALUE *argv, VALUE self) {
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	char *str = RSTRING_PTR(v);
	ofstream fs;
	fs.open(str);
	if(fs.is_open()){
		CsvoutCtoI(*rmod->cmod,fs);
		fs.close();
	}
	else{
		rb_raise(rb_eRuntimeError,"file oepn error");
	}
	return self;
}

.delta(*args) ⇒ Object

##vsop_delta##

# File 'ext/zdd_so/zdd_so.cpp', line 2336

VALUE vsop_delta(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	*ctoi_moda = CtoI_Delta(*ctoi_moda, *ctoi_modc);
  ctoi_fin = ctoi_moda;
  delete ctoi_modc;
	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.density ⇒ Object

##vsop_print_density##

# File 'ext/zdd_so/zdd_so.cpp', line 2816

VALUE vsop_print_density( VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	auto_ptr<CtoI> auto_p(new CtoI(*rmod->cmod));
	CtoI *ctoitmp = auto_p.get();

	*ctoitmp = ctoitmp -> NonZero();
	if(*ctoitmp == CtoI_Null())
	{
		*ctoitmp = 0;
		rb_raise(rb_eRuntimeError,"07Memory overflow");
	}
	int d = Density(ctoitmp -> GetZBDD(), VTable.Used());
	if(d == 0 && *ctoitmp != 0){
		rb_raise(rb_eRuntimeError,"Bit underflow occurred");
	}
	VALUE rtn = rb_float_new((float)d / power30);
	return rtn;
}

.diff?(*args) ⇒ Boolean

##vsop_diff##

Returns:

• (Boolean)

# File 'ext/zdd_so/zdd_so.cpp', line 2757

VALUE vsop_diff(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	
	CtoI *ctoi_modc = value2ctoi(v);
	if ( *rmod->cmod != *ctoi_modc){
		return Qtrue;
	} 
	else{
		return  Qfalse;
	}
}

.each ⇒ Object

##vsop_each##

# File 'ext/zdd_so/zdd_so.cpp', line 1972

VALUE vsop_each(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
 	CtoI2Array_each(*rmod->cmod,self);
	return Qtrue;	
}

.each_item ⇒ Object

##vsop_each_item##

# File 'ext/zdd_so/zdd_so.cpp', line 2277

VALUE vsop_each_item(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
 	CtoI2ItemArray(*rmod->cmod,self);
	return Qtrue;	
}

.export(*args) ⇒ Object

##vsop_print_export##

# File 'ext/zdd_so/zdd_so.cpp', line 3031

VALUE vsop_print_export(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	auto_ptr<CtoI> auto_p(new CtoI(*rmod->cmod));
	CtoI *ctoitmp = auto_p.get();
	FILE *fp=NULL;
	if(argc==1){
		VALUE v1;
		rb_scan_args(argc, argv,"0*",&v1);
		if(TYPE(RARRAY_PTR(v1)[0])==T_STRING){
				char *str = RSTRING_PTR(RARRAY_PTR(v1)[0]);
				fp = fopen(str, "w");
				if(fp == NULL){
					rb_raise(rb_eRuntimeError,"Can't open the file");		
				}
		}
		else{
			rb_raise(rb_eRuntimeError,"argument type error (1st argument must be STRING)");
		}
	}
	else if(argc!=0){
		rb_raise(rb_eRuntimeError,"number of argument is 0 or 1 ");		
	}

	int d = ctoitmp -> TopDigit();
	ZBDDV v = ZBDDV();
	for(int i=0; i<=d; i++){
		v += ZBDDV(ctoitmp -> Digit(i).GetZBDD(), i);
	}

	if(fp){
		v.Export(fp);
		fclose(fp);
	}else{
		v.Export();
	}
	return self;
}

.freqpatA(*args) ⇒ Object

##vsop_freqpatA##

# File 'ext/zdd_so/zdd_so.cpp', line 562

VALUE vsop_freqpatA(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FreqPatA(ctoi_modd->GetInt() );
      //*ctoi_moda = ctoi_moda -> ReduceItems(ctoi_moda->TotalValItems().GE_Const(*ctoi_modd)).FreqPatA(ctoi_modd->GetInt());
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.freqpatC(*args) ⇒ Object

##vsop_freqpatC##

# File 'ext/zdd_so/zdd_so.cpp', line 599

VALUE vsop_freqpatC(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FreqPatC(ctoi_modd->GetInt() );
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.freqpatM(*args) ⇒ Object

##vsop_freqpatM##

# File 'ext/zdd_so/zdd_so.cpp', line 581

VALUE vsop_freqpatM(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FreqPatM(ctoi_modd->GetInt() );
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.hashout ⇒ Object

##vsop_hashout##

# File 'ext/zdd_so/zdd_so.cpp', line 1879

VALUE vsop_hashout(VALUE self){
	int rtnflg=0;
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
 	VALUE hash = HashoutCtoI(*rmod->cmod,&rtnflg);
	if(rtnflg==2){
		rb_iv_set(self,"@partly", Qtrue );
	}
	else{
		rb_iv_set(self,"@partly", Qfalse);
	}
	return hash;
}

.iif(*args) ⇒ Object

##vsop_iif##

# File 'ext/zdd_so/zdd_so.cpp', line 1025

VALUE vsop_iif(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v1;
	VALUE v2;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"20",&v1,&v2);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v1);
	CtoI *ctoi_mode = value2ctoi(v2);
	CtoI *ctoi_fin; 
	      *ctoi_moda = CtoI_ITE(*ctoi_moda, *ctoi_modc, *ctoi_mode);
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;
      delete ctoi_mode;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.import(*args) ⇒ Object

##vsop_import##

# File 'ext/zdd_so/zdd_so.cpp', line 631

VALUE vsop_import(int argc, VALUE *argv, VALUE self){
	VALUE v;
	CtoI *ctoi_fin; 
/*
	VALUE vz = rb_cv_get(self,"@@init_cnt");
	int init_cnt_v =  NUM2INT(vz);
	if(init_cnt_v==0){ BDDV_Init(256, env_nmax);}
	init_cnt_v++;
	rb_cv_set(self,"@@init_cnt",INT2NUM(init_cnt_v));
*/
	if(init_cnt==0){ BDDV_Init(256, env_nmax);}
	init_cnt++;

	rb_scan_args(argc, argv,"10",&v);
	if(TYPE(v)!=T_STRING){
		rb_raise(rb_eRuntimeError,"argument type error (1st argument must be STRING)");
	}
	char *argtmp = RSTRING_PTR(v);
	int len;
	len = strlen(argtmp);
	char *str_c = new char[len+3];
	sprintf(str_c,"\"%s\"",argtmp);
	int len_c = len+2;
	      str_c[len_c - 1] = 0;
      FILE *fp;
      fp = fopen(str_c+1, "r");
      if(fp == NULL)
      {
        yyerror("Can't open the file");
	ctoi_fin = new CtoI(0);
      }
      else
      {
	ZBDDV v = ZBDDV_Import(fp);
	fclose(fp);
	if(v != ZBDDV(-1))
	{
	  int t = 1;
	  char s[32];
	  while(BDD_LevOfVar(v.Top()) > VTable.Used())
	  {
	    sprintf(s, "x%d", t);
	    while(VTable.GetID(s) != 0)
	    {
	      t++;
	      sprintf(s, "x%d", t);
	    }
	    VTable.SetT0(BDD_VarOfLev(t), s);
	  }
	  int len = v.Last()+1;
	  CtoI a = CtoI(0);
	  for(int i=0; i<len; i++)
	    a += CtoI(v.GetZBDD(i)).ShiftDigit(i);
          ctoi_fin = new CtoI(a);
	}
	else
	{
          yyerror("<WARNING> import error");
	  ctoi_fin = new CtoI(0);
	}
      }
      delete[] str_c;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.inspect ⇒ Object

##vsop_to_s##

# File 'ext/zdd_so/zdd_so.cpp', line 2188

VALUE vsop_to_s(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
 	VALUE str = CtoI2String(*rmod->cmod);
	return str;
}

.items ⇒ Object

##vsop_items##

# File 'ext/zdd_so/zdd_so.cpp', line 440

VALUE vsop_items(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> TotalValItems();
      ctoi_fin = ctoi_moda;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.itemset(*args) ⇒ Object

##vsop_itemset##

# File 'ext/zdd_so/zdd_so.cpp', line 2498

VALUE vsop_itemset(int argc, VALUE *argv, VALUE self)
{
	Vsop_Ruby* rmod=new Vsop_Ruby;
	VALUE v;

	//引数読み込み
	rb_scan_args(argc, argv,"10",&v);
	if(TYPE(v)!=T_STRING){
		rb_raise(rb_eRuntimeError,"argument type error (arguments must be STRING)");
	}
	
	char *str = RSTRING_PTR(v);
	if (*str =='\0'){
	 	rmod->cmod = int2ctoi(1);
	}
	else{
		rmod->cmod = string2ctoi(str);
	}

	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod);
}

.lcm(*args) ⇒ Object

##vsop_lcm##

# File 'ext/zdd_so/zdd_so.cpp', line 2713

VALUE vsop_lcm(int argc, VALUE *argv, VALUE self)
{
	VALUE rtnval;
	if(argc==3){
		rtnval = vsop_lcm_nomal(argc,argv,self);
	}
	else if(argc==4){
		rtnval = vsop_lcm_order(argc,argv,self);
	}
	else if(argc==5){
		VALUE v1,v2,v3,v4,v5;
		rb_scan_args(argc, argv,"50",&v1,&v2,&v3,&v4,&v5);
		if(TYPE(v4)!=T_STRING || strcmp(RSTRING_PTR(v4),"")==0  ){
			rtnval = vsop_lcm_nomal_ub(v1,v2,v3,v5,self);
		}
		else{
			rtnval = vsop_lcm_order_ub(v1,v2,v3,v4,v5,self);
		}
	}
	else{
		rb_raise(rb_eRuntimeError,"argument size error ");
	}
	return rtnval;
}

.maxcost ⇒ Object

##vsop_print_maxcost##

# File 'ext/zdd_so/zdd_so.cpp', line 2903

VALUE vsop_print_maxcost( VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	auto_ptr<CtoI> auto_p(new CtoI(*rmod->cmod));
	CtoI *ctoitmp = auto_p.get();

	*ctoitmp = ctoitmp -> NonZero();
	if(*ctoitmp == CtoI_Null())
	{
		*ctoitmp = 0;
		rb_raise(rb_eRuntimeError,"09Memory overflow");
	}
	VALUE rtn;
	if(*ctoitmp == 0){
		rtn = 	Qnil;
	}
	else
	{
		int c = MaxCost(ctoitmp -> GetZBDD());
		rtn = rb_float_new((float)c/power16);
	}
	return rtn;
}

.maxcover ⇒ Object

##vsop_print_maxcover##

# File 'ext/zdd_so/zdd_so.cpp', line 2851

VALUE vsop_print_maxcover(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);

	CtoI *ctoi_fin; 

	auto_ptr<CtoI> auto_p(new CtoI(*rmod->cmod));
	CtoI *ctoitmp = auto_p.get();
	
	*ctoitmp = ctoitmp -> NonZero();
	if(*ctoitmp == CtoI_Null())
	{
		*ctoitmp = 0;
		ctoi_fin = new CtoI(0);
		rb_raise(rb_eRuntimeError,"08Memory overflow");
	}
	if(*ctoitmp == 0){
		ctoi_fin = new CtoI(0);
	}
	else
	{
		ZBDD f = ctoitmp -> GetZBDD();
		if(MaxCost(f)==0){
			ctoi_fin = new CtoI(1);
		}
		else
		{
			CtoI ctmp(1);
			while(1)
			{
				int var = f.Top();
				if(var == 0) break;
				ZBDD f0 = f.OffSet(var);
				ZBDD f1 = f.OnSet0(var);
				int c1 = MaxCost(f1) + VTable.GetValue(var);
				if(MaxCost(f0) < c1)
				{
					f = f1;
					ctmp = ctmp.AffixVar(var);
				}
				else f = f0;
			}
			ctoi_fin = new CtoI(ctmp);
		}
	}

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.maxweight ⇒ Object

##vsop_maxval##

# File 'ext/zdd_so/zdd_so.cpp', line 333

VALUE vsop_maxval(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> MaxVal();
      ctoi_fin = ctoi_moda;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.meet(*args) ⇒ Object

##vsop_meet##

# File 'ext/zdd_so/zdd_so.cpp', line 898

VALUE vsop_meet(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = CtoI_Meet(*ctoi_moda, *ctoi_modc);
      //*ctoi_moda = ZBDD_Meet(ctoi_moda->NonZero().GetZBDD(), ctoi_modc->NonZero().GetZBDD());
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.mincost ⇒ Object

##vsop_print_mincost##

# File 'ext/zdd_so/zdd_so.cpp', line 2979

VALUE vsop_print_mincost( VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	auto_ptr<CtoI> auto_p(new CtoI(*rmod->cmod));
	CtoI *ctoitmp = auto_p.get();
	
	*ctoitmp = ctoitmp -> NonZero();
	if(*ctoitmp == CtoI_Null())
	{
		*ctoitmp = 0;
		rb_raise(rb_eRuntimeError,"11Memory overflow");
	}
	VALUE rtn;
	if(*ctoitmp == 0){
		rtn = Qnil;
	}
	else
	{
		int c = MinCost(ctoitmp -> GetZBDD());
		rtn = rb_float_new((float)c/power16);
	}
	return rtn;
}

.mincover ⇒ Object

##vsop_print_mincover##

# File 'ext/zdd_so/zdd_so.cpp', line 2928

VALUE vsop_print_mincover( VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);

	CtoI *ctoi_fin; 

	auto_ptr<CtoI> auto_p(new CtoI(*rmod->cmod));
	CtoI *ctoitmp = auto_p.get();
	
	*ctoitmp = ctoitmp -> NonZero();
	if(*ctoitmp == CtoI_Null())
	{
		*ctoitmp = 0;
		ctoi_fin = new CtoI(0);
		rb_raise(rb_eRuntimeError,"10Memory overflow");
	}
	if(*ctoitmp == 0){
		ctoi_fin = new CtoI(0);
	}
	else
	{
		ZBDD f = ctoitmp -> GetZBDD();
		if(MinCost(f)==0){
			ctoi_fin = new CtoI(1);
		}
		else
		{
			CtoI ctmp(1);
			while(1)
			{
				int var = f.Top();
				if(var == 0) break;
				ZBDD f0 = f.OffSet(var);
				ZBDD f1 = f.OnSet0(var);
				int c1 = MinCost(f1) + VTable.GetValue(var);
				if(MinCost(f0) > c1)
				{
					f = f1;
					ctmp = ctmp.AffixVar(var);
				}
				else f = f0;
			}
			ctoi_fin = new CtoI(ctmp);
		}
	}
	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.minweight ⇒ Object

##vsop_minval##

# File 'ext/zdd_so/zdd_so.cpp', line 347

VALUE vsop_minval(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> MinVal();
      ctoi_fin = ctoi_moda;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.ne?(*args) ⇒ Boolean

##vsop_ne##

Returns:

• (Boolean)

# File 'ext/zdd_so/zdd_so.cpp', line 935

VALUE vsop_ne(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modc = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = CtoI_NE(*ctoi_moda, *ctoi_modc);
      ctoi_fin = ctoi_moda;
      delete ctoi_modc;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.partly ⇒ Object

##vsop_partly##

# File 'ext/zdd_so/zdd_so.cpp', line 3146

VALUE vsop_partly(VALUE self){
	return rb_iv_get(self,"@partly");
}

.permit(*args) ⇒ Object

##vsop_permit##

# File 'ext/zdd_so/zdd_so.cpp', line 404

VALUE vsop_permit(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterPermit(*ctoi_modd);
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.permitsym(*args) ⇒ Object

##vsop_permitsym##

# File 'ext/zdd_so/zdd_so.cpp', line 422

VALUE vsop_permitsym(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterPermitSym(ctoi_modd->GetInt());
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.restrict(*args) ⇒ Object

##vsop_restrict##

# File 'ext/zdd_so/zdd_so.cpp', line 386

VALUE vsop_restrict(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterRestrict(*ctoi_modd);
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.same?(*args) ⇒ Boolean

##vsop_same##

Returns:

• (Boolean)

# File 'ext/zdd_so/zdd_so.cpp', line 2741

VALUE vsop_same(int argc, VALUE *argv,VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	
	CtoI *ctoi_modc = value2ctoi(v);
	if ( *rmod->cmod == *ctoi_modc){
		return Qtrue;
	} 
	else{
		return  Qfalse;
	}
}

.show(*args) ⇒ Object

##vsop_show##

# File 'ext/zdd_so/zdd_so.cpp', line 3092

VALUE vsop_show(int argc, VALUE *argv, VALUE self){
	// bit,hex,map,rmap,case,decompのみ動くようにする
	VALUE rtnval;
	if(argc == 0){
		rtnval = vsop_print(self);
	}
	else if(argc == 1)	{
		VALUE v;
		rb_scan_args(argc, argv,"10",&v);
		if(TYPE(v)!=T_STRING){
			rb_raise(rb_eRuntimeError,"argument type error (1st argument must be STRING)");
		}
		char *argtmp = RSTRING_PTR(v);
		for(size_t i=0;*show_use_para[i][0]!='\0';i++){
			if( !strcmp(argtmp,show_use_para[i][0])|| 
				!strcmp(argtmp,show_use_para[i][1])){
				rtnval = vsop_print_arg1(self,show_use_para[i][0]);
				return rtnval;
			}		
		}
		bool output = true;
		for(const char *p=*show_notuse_para ;*p!='\0';p++){
			if( !strcmp(argtmp,p)){
				output=false;
				break;
			}
		}
		if(output){
			rtnval = vsop_print_arg1(self,argtmp);
			return rtnval;
		}
		rb_raise(rb_eRuntimeError,"Illegal switch(/bit,/hex,/map,/rmap,/case,/decomp)");
	}
	else	if(argc == 2)
	{
		VALUE v1,v2;
		rb_scan_args(argc, argv,"20",&v1,&v2);
		char *argtmp = RSTRING_PTR(v1);
		for(size_t i=0;*show_use_para[i][0]!='\0';i++){
			if( !strcmp(argtmp,show_use_para[i][0])|| 
				!strcmp(argtmp,show_use_para[i][1])){
				rtnval = vsop_print_arg2(argc,argv,self);
				return rtnval;
			}		
		}
		rb_raise(rb_eRuntimeError,"parameter error(/bit,/hex,/map,/rmap,/case,/decomp)");
	}
	else{
		rb_raise(rb_eRuntimeError,"number of argument is 0 or 1 or 2");
	}
	return rtnval;
}

.size ⇒ Object

##vsop_print_size##

# File 'ext/zdd_so/zdd_so.cpp', line 2773

VALUE vsop_print_size( VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	int val = rmod->cmod->Size();
	return INT2NUM(val);
}

.symbol(*args) ⇒ Object

##vsop_symbol##

# File 'ext/zdd_so/zdd_so.cpp', line 2430

VALUE vsop_symbol(int argc, VALUE *argv, VALUE self) 
{
	//引数読み込み
	VALUE rtn;
	//初回呼び出し時のみBDDの初期化	
	if(init_cnt==0){ BDDV_Init(256, env_nmax);}
	init_cnt++;

	if(argc>=1){
		int val=power16/2;
		char *to ="bottom";
		char *str;
		VALUE v1,v2,v3;
		rb_scan_args(argc, argv,"12",&v1,&v2,&v3);
		switch(argc){
			case 3:
				if(TYPE(v3)!=T_STRING){
					rb_raise(rb_eRuntimeError,"argument type error (arguments must be STRING)");
				}
				to = RSTRING_PTR(v3);				
			case 2:
				if(TYPE(v2)==T_FLOAT){
					val = (int)( NUM2DBL(v2)*power16);
				}
				else if(TYPE(v2)==T_FIXNUM){
					val =  NUM2INT(v2)*power16;
				}
				else if(TYPE(v2)==T_NIL){
				}				
				else{
					rb_raise(rb_eRuntimeError,"argument type error (arguments must be FLOAT or INT or NIL)");
				}				
			case 1:
				if(TYPE(v1)!=T_STRING){
					rb_raise(rb_eRuntimeError,"argument type error (arguments must be STRING)");
				}
				str = RSTRING_PTR(v1);
				//数値チェック（アイテムが数値なら警告）
				if(env_warning){ num_check(str); }
				break;
			default:
				rb_raise(rb_eRuntimeError,"argument type error");
				break;
		}
		if(*str!='\0'){
			int var = VTable.GetID(str);
			if(var == 0){
				if(!strcmp(to,"top"))	{ VTable.SetT(str, val);}
				else					{ VTable.SetB(str, val);}
			}
		}
		rtn = Qtrue;
	}
	else{
		int n = VTable.Used();
		string str ;
		for(int i=n; i>0; i--)
		{
			int var = BDD_VarOfLev(i);
			str += VTable.GetName(var);
			str += " ";
		}
		rtn = rb_str_new2(str.c_str());
	}
	return rtn;
}

.symgrp ⇒ Object

##vsop_symgrp##

# File 'ext/zdd_so/zdd_so.cpp', line 617

VALUE vsop_symgrp(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> NonZero().GetZBDD().SymGrp();
      ctoi_fin = ctoi_moda;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.termsEQ(*args) ⇒ Object

##vsop_termsEQ##

# File 'ext/zdd_so/zdd_so.cpp', line 454

VALUE vsop_termsEQ(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterThen(ctoi_moda -> EQ_Const(ctoi_modd->GetInt()));
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.termsGE(*args) ⇒ Object

##vsop_termsGE##

# File 'ext/zdd_so/zdd_so.cpp', line 508

VALUE vsop_termsGE(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterThen(ctoi_moda -> GE_Const(ctoi_modd->GetInt()));
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.termsGT(*args) ⇒ Object

##vsop_termsGT##

# File 'ext/zdd_so/zdd_so.cpp', line 490

VALUE vsop_termsGT(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterThen(ctoi_moda -> GT_Const(ctoi_modd->GetInt()));
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.termsLE(*args) ⇒ Object

##vsop_termsLE##

# File 'ext/zdd_so/zdd_so.cpp', line 544

VALUE vsop_termsLE(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterThen(ctoi_moda -> LE_Const(ctoi_modd->GetInt()));
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.termsLT(*args) ⇒ Object

##vsop_termsLT##

# File 'ext/zdd_so/zdd_so.cpp', line 526

VALUE vsop_termsLT(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterThen(ctoi_moda -> LT_Const(ctoi_modd->GetInt()));
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.termsNE(*args) ⇒ Object

##vsop_termsNE##

# File 'ext/zdd_so/zdd_so.cpp', line 472

VALUE vsop_termsNE(int argc, VALUE *argv, VALUE self){
	Vsop_Ruby* rmod;
	VALUE v;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
	rb_scan_args(argc, argv,"10",&v);
	CtoI *ctoi_moda =new CtoI(*rmod->cmod);
	CtoI *ctoi_modd = value2ctoi(v);
	CtoI *ctoi_fin; 
	      *ctoi_moda = ctoi_moda -> FilterThen(ctoi_moda -> NE_Const(ctoi_modd->GetInt()));
      ctoi_fin = ctoi_moda;
      delete ctoi_modd;

	Vsop_Ruby *rmod_rtn = new Vsop_Ruby;
	rmod_rtn->cmod = ctoi_fin;
	return Data_Wrap_Struct(rb_class_of(self),0,free_rmod,rmod_rtn);
}

.to_a ⇒ Object

##vsop_to_a##

# File 'ext/zdd_so/zdd_so.cpp', line 2093

VALUE vsop_to_a(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
 	VALUE array = CtoI2Array(*rmod->cmod);

	return array;
}

.to_i ⇒ Object

##vsop_const_to_i##

# File 'ext/zdd_so/zdd_so.cpp', line 3161

VALUE vsop_const_to_i(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);

	CtoI a = *(rmod->cmod);
	
	if(a.IsConst()){
		if(a.TopItem() > 0) a = a.MaxVal();
		int d = a.TopDigit() / 3 + 14;
		kgAutoPtr2<char> a_ptr;
		char *s;
		try{
			a_ptr.set(new char[d]);
			s = a_ptr.get();
		}catch(...){
			rb_raise(rb_eRuntimeError,"memory allocation error");
		}
	  int err = a.StrNum10(s);
	  if (err) { rb_raise(rb_eRuntimeError,"StrNum10 error"); }
		return rb_cstr2inum(s,10);
	}else{
		return Qnil;
	}
}

.to_s ⇒ Object

##vsop_to_s##

# File 'ext/zdd_so/zdd_so.cpp', line 2188

VALUE vsop_to_s(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);
 	VALUE str = CtoI2String(*rmod->cmod);
	return str;
}

.totalsize ⇒ Object

##vsop_print_totalsize##

# File 'ext/zdd_so/zdd_so.cpp', line 2781

VALUE vsop_print_totalsize(VALUE self){
	rb_gc();
	BDD_GC();
	VALUE rtn = INT2NUM(BDD_Used());

	return rtn;
}

.totalweight ⇒ Object

##vsop_totalval##

# File 'ext/zdd_so/zdd_so.cpp', line 361

VALUE vsop_totalval(VALUE self){
	Vsop_Ruby* rmod;
	Data_Get_Struct(self,Vsop_Ruby,rmod);

	CtoI a = rmod->cmod->TotalVal();	
	if(a.IsConst())
	{	
		if(a.TopItem() > 0) a = a.MaxVal();
		int d = a.TopDigit() / 3 + 14;
		kgAutoPtr2<char> a_ptr;
		char *s;
		try{
			a_ptr.set(new char[d]);
			s = a_ptr.get();
		}catch(...){
			rb_raise(rb_eRuntimeError,"memory allocation error");
		}
	  int err = a.StrNum10(s);
	  if (err) { rb_raise(rb_eRuntimeError,"StrNum10 error"); }
		return rb_cstr2inum(s,10);
	}
	return 0;
}