static VALUE rb_gsl_function_graph(int argc, VALUE *argv, VALUE obj) { #ifdef HAVE_GNU_GRAPH gsl_function *F = NULL; gsl_vector *v = NULL; double x, y; char opt[256] = "", command[1024]; size_t i, n; int flag = 0; FILE *fp = NULL; VALUE ary, params, proc; switch (argc) { case 2: Check_Type(argv[1], T_STRING); strcpy(opt, STR2CSTR(argv[1])); /* no break, do next */ case 1: if (CLASS_OF(argv[0]) == rb_cRange) argv[0] = rb_gsl_range2ary(argv[0]); if (TYPE(argv[0]) == T_ARRAY) { n = RARRAY(argv[0])->len; v = gsl_vector_alloc(n); flag = 1; for (i = 0; i < n; i++) gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(argv[0], i))); } else if (rb_obj_is_kind_of(argv[0], cgsl_vector)) { Data_Get_Struct(argv[0], gsl_vector, v); n = v->size; flag = 0; } else { rb_raise(rb_eTypeError, "wrong argument type %s (Array or GSL::Vector expected)", rb_class2name(CLASS_OF(argv[0]))); } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc); break; } Data_Get_Struct(obj, gsl_function, F); ary = (VALUE) F->params; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); sprintf(command, "graph -T X -g 3 %s", opt); fp = popen(command, "w"); if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found."); for (i = 0; i < n; i++) { x = gsl_vector_get(v, i); if (NIL_P(params)) y = NUM2DBL(rb_funcall(proc, RBGSL_ID_call, 1, rb_float_new(x))); else y = NUM2DBL(rb_funcall(proc, RBGSL_ID_call, 2, rb_float_new(x), params)); fprintf(fp, "%e %e\n", x, y); } fflush(fp); pclose(fp); fp = NULL; if (flag == 1) gsl_vector_free(v); return Qtrue; #else rb_raise(rb_eNoMethodError, "not implemented"); return Qfalse; #endif }
static VALUE rb_ool_conmin_minimizer_size(VALUE obj) { ool_conmin_minimizer *m; Data_Get_Struct(obj, ool_conmin_minimizer, m); return rb_float_new(ool_conmin_minimizer_size(m)); }
void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler, const char* function_name) { int i; VALUE result, doc; VALUE *argv; VALUE node_set = Qnil; xmlNodeSetPtr xml_node_set = NULL; xmlXPathObjectPtr obj; nokogiriNodeSetTuple *node_set_tuple; assert(ctx->context->doc); assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc)); argv = (VALUE *)calloc((size_t)nargs, sizeof(VALUE)); for (i = 0 ; i < nargs ; ++i) { rb_gc_register_address(&argv[i]); } doc = DOC_RUBY_OBJECT(ctx->context->doc); if (nargs > 0) { i = nargs - 1; do { obj = valuePop(ctx); switch(obj->type) { case XPATH_STRING: argv[i] = NOKOGIRI_STR_NEW2(obj->stringval); break; case XPATH_BOOLEAN: argv[i] = obj->boolval == 1 ? Qtrue : Qfalse; break; case XPATH_NUMBER: argv[i] = rb_float_new(obj->floatval); break; case XPATH_NODESET: argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval, doc); break; default: argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj)); } xmlXPathFreeNodeSetList(obj); } while(i-- > 0); } result = rb_funcall2(handler, rb_intern((const char*)function_name), nargs, argv); for (i = 0 ; i < nargs ; ++i) { rb_gc_unregister_address(&argv[i]); } free(argv); switch(TYPE(result)) { case T_FLOAT: case T_BIGNUM: case T_FIXNUM: xmlXPathReturnNumber(ctx, NUM2DBL(result)); break; case T_STRING: xmlXPathReturnString( ctx, xmlCharStrdup(StringValuePtr(result)) ); break; case T_TRUE: xmlXPathReturnTrue(ctx); break; case T_FALSE: xmlXPathReturnFalse(ctx); break; case T_NIL: break; case T_ARRAY: { VALUE args[2]; args[0] = doc; args[1] = result; node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet); Data_Get_Struct(node_set, nokogiriNodeSetTuple, node_set_tuple); xml_node_set = node_set_tuple->node_set; xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set)); } break; case T_DATA: if(rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) { Data_Get_Struct(result, nokogiriNodeSetTuple, node_set_tuple); xml_node_set = node_set_tuple->node_set; /* Copy the node set, otherwise it will get GC'd. */ xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set)); break; } default: rb_raise(rb_eRuntimeError, "Invalid return type"); } }
/* call-seq: total_time -> float Returns the total amount of time spent in this method and its children. */ static VALUE prof_call_info_total_time(VALUE self) { prof_call_info_t *result = prof_get_call_info(self); return rb_float_new(result->total_time); }
/* * Converts a D time metric to a Ruby float in ms */ static VALUE rb_io_convert_time(uint64_t t) { return rb_float_new((double) t / 1000000); }
/* call-seq: * music.getDuration() -> float * * Get the total duration of the music. */ static VALUE Music_GetDuration( VALUE self ) { sf::Music *object = NULL; Data_Get_Struct( self, sf::Music, object ); return rb_float_new( object->GetDuration() ); }
static VALUE t_to_mel(VALUE self, VALUE m) { return rb_float_new(mel(NUM2DBL(m))); }
static VALUE rb_cqpminimizer_gap(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return rb_float_new(gsl_cqpminimizer_gap(m)); }
static VALUE rb_cqpminimizer_residuals_norm(VALUE obj) { gsl_cqpminimizer *m; Data_Get_Struct(obj, gsl_cqpminimizer, m); return rb_float_new(gsl_cqpminimizer_residuals_norm(m)); }
static VALUE t_get_comm_inactivity_timeout (VALUE self UNUSED, VALUE signature) { return rb_float_new(evma_get_comm_inactivity_timeout(NUM2BSIG (signature))); }
static VALUE t_get_pending_connect_timeout (VALUE self UNUSED, VALUE signature) { return rb_float_new(evma_get_pending_connect_timeout(NUM2BSIG (signature))); }
static VALUE t_get_heartbeat_interval (VALUE self UNUSED) { return rb_float_new(evma_get_heartbeat_interval()); }
/* * Document-class: PG::TextDecoder::Float < PG::SimpleDecoder * * This is a decoder class for conversion of PostgreSQL float4 and float8 types * to Ruby Float objects. * */ static VALUE pg_text_dec_float(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx) { return rb_float_new(strtod(val, NULL)); }
static VALUE rb_cpBBGetT(VALUE self) { return rb_float_new(BBGET(self)->t); }
void Init_carray_numeric () { /* hack Fixnum and Bignum's "|", "&", "^", "<<", ">>" */ id___or__ = rb_intern("__or__"); id___and__ = rb_intern("__and__"); id___xor__ = rb_intern("__xor__"); id___rshift__ = rb_intern("__rshift__"); id___lshift__ = rb_intern("__lshift__"); CA_NAN = rb_float_new(0.0/0.0); CA_INF = rb_float_new(1.0/0.0); rb_define_const(rb_cObject, "CA_NAN", CA_NAN); rb_define_const(rb_cObject, "CA_INF", CA_INF); rb_define_global_function("nan", rb_num_nan, 0); rb_define_global_function("inf", rb_num_inf, 0); rb_define_alias(rb_cTrueClass, "__or__", "|"); rb_define_alias(rb_cTrueClass, "__and__", "&"); rb_define_alias(rb_cTrueClass, "__xor__", "^"); rb_define_alias(rb_cFalseClass, "__or__", "|"); rb_define_alias(rb_cFalseClass, "__and__", "&"); rb_define_alias(rb_cFalseClass, "__xor__", "^"); rb_define_alias(rb_cFixnum, "__or__", "|"); rb_define_alias(rb_cFixnum, "__and__", "&"); rb_define_alias(rb_cFixnum, "__xor__", "^"); rb_define_alias(rb_cFixnum, "__lshift__", "<<"); rb_define_alias(rb_cFixnum, "__rshift__", ">>"); rb_define_alias(rb_cBignum, "__or__", "|"); rb_define_alias(rb_cBignum, "__and__", "&"); rb_define_alias(rb_cBignum, "__xor__", "^"); rb_define_alias(rb_cBignum, "__lshift__", "<<"); rb_define_alias(rb_cBignum, "__rshift__", ">>"); rb_define_method(rb_cTrueClass, "|", rb_hack_or, 1); rb_define_method(rb_cTrueClass, "&", rb_hack_and, 1); rb_define_method(rb_cTrueClass, "^", rb_hack_xor, 1); rb_define_method(rb_cTrueClass, "*", rb_hack_star, 1); rb_define_method(rb_cFalseClass, "|", rb_hack_or, 1); rb_define_method(rb_cFalseClass, "&", rb_hack_and, 1); rb_define_method(rb_cFalseClass, "^", rb_hack_xor, 1); rb_define_method(rb_cFalseClass, "*", rb_hack_star, 1); rb_define_method(rb_cFixnum, "|", rb_hack_or, 1); rb_define_method(rb_cFixnum, "&", rb_hack_and, 1); rb_define_method(rb_cFixnum, "^", rb_hack_xor, 1); rb_define_method(rb_cFixnum, "<<", rb_hack_lshift, 1); rb_define_method(rb_cFixnum, ">>", rb_hack_rshift, 1); rb_define_method(rb_cBignum, "|", rb_hack_or, 1); rb_define_method(rb_cBignum, "&", rb_hack_and, 1); rb_define_method(rb_cBignum, "^", rb_hack_xor, 1); rb_define_method(rb_cBignum, "<<", rb_hack_lshift, 1); rb_define_method(rb_cBignum, ">>", rb_hack_rshift, 1); #ifdef HAVE_COMPLEX_H rb_define_method(rb_cCArray, "arg", rb_ca_arg, 0); #endif }
void callback(ffi_cif *cif, void *resp, void **args, void *ctx) { VALUE self = (VALUE)ctx; VALUE rbargs = rb_iv_get(self, "@args"); VALUE ctype = rb_iv_get(self, "@ctype"); int argc = RARRAY_LENINT(rbargs); VALUE *params = xcalloc(argc, sizeof(VALUE *)); VALUE ret; VALUE cPointer; int i, type; cPointer = rb_const_get(mFiddle, rb_intern("Pointer")); for (i = 0; i < argc; i++) { type = NUM2INT(RARRAY_PTR(rbargs)[i]); switch (type) { case TYPE_VOID: argc = 0; break; case TYPE_INT: params[i] = INT2NUM(*(int *)args[i]); break; case TYPE_VOIDP: params[i] = rb_funcall(cPointer, rb_intern("[]"), 1, PTR2NUM(*(void **)args[i])); break; case TYPE_LONG: params[i] = LONG2NUM(*(long *)args[i]); break; case TYPE_CHAR: params[i] = INT2NUM(*(char *)args[i]); break; case TYPE_DOUBLE: params[i] = rb_float_new(*(double *)args[i]); break; case TYPE_FLOAT: params[i] = rb_float_new(*(float *)args[i]); break; #if HAVE_LONG_LONG case TYPE_LONG_LONG: params[i] = rb_ull2inum(*(unsigned LONG_LONG *)args[i]); break; #endif default: rb_raise(rb_eRuntimeError, "closure args: %d", type); } } ret = rb_funcall2(self, rb_intern("call"), argc, params); type = NUM2INT(ctype); switch (type) { case TYPE_VOID: break; case TYPE_LONG: *(long *)resp = NUM2LONG(ret); break; case TYPE_CHAR: *(char *)resp = NUM2INT(ret); break; case TYPE_VOIDP: *(void **)resp = NUM2PTR(ret); break; case TYPE_INT: *(int *)resp = NUM2INT(ret); break; case TYPE_DOUBLE: *(double *)resp = NUM2DBL(ret); break; case TYPE_FLOAT: *(float *)resp = (float)NUM2DBL(ret); break; #if HAVE_LONG_LONG case TYPE_LONG_LONG: *(unsigned LONG_LONG *)resp = rb_big2ull(ret); break; #endif default: rb_raise(rb_eRuntimeError, "closure retval: %d", type); } xfree(params); }
static void ruby_funcall(xmlXPathParserContextPtr ctx, int nargs) { VALUE xpath_handler = Qnil; VALUE result; VALUE *argv; VALUE doc; VALUE node_set = Qnil; xmlNodeSetPtr xml_node_set = NULL; xmlXPathObjectPtr obj; int i; assert(ctx); assert(ctx->context); assert(ctx->context->userData); assert(ctx->context->doc); assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc)); xpath_handler = (VALUE)(ctx->context->userData); argv = (VALUE *)calloc((unsigned int)nargs, sizeof(VALUE)); doc = DOC_RUBY_OBJECT(ctx->context->doc); i = nargs - 1; do { obj = valuePop(ctx); switch(obj->type) { case XPATH_STRING: argv[i] = NOKOGIRI_STR_NEW2(obj->stringval); break; case XPATH_BOOLEAN: argv[i] = obj->boolval == 1 ? Qtrue : Qfalse; break; case XPATH_NUMBER: argv[i] = rb_float_new(obj->floatval); break; case XPATH_NODESET: argv[i] = Nokogiri_wrap_xml_node_set(obj->nodesetval, doc); break; default: argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj)); } xmlXPathFreeNodeSetList(obj); } while(i-- > 0); result = rb_funcall2( xpath_handler, rb_intern((const char *)ctx->context->function), nargs, argv ); free(argv); switch(TYPE(result)) { case T_FLOAT: case T_BIGNUM: case T_FIXNUM: xmlXPathReturnNumber(ctx, NUM2DBL(result)); break; case T_STRING: xmlXPathReturnString( ctx, (xmlChar *)xmlXPathWrapCString(StringValuePtr(result)) ); break; case T_TRUE: xmlXPathReturnTrue(ctx); break; case T_FALSE: xmlXPathReturnFalse(ctx); break; case T_NIL: break; case T_ARRAY: { VALUE args[2]; args[0] = doc; args[1] = result; node_set = rb_class_new_instance(2, args, cNokogiriXmlNodeSet); Data_Get_Struct(node_set, xmlNodeSet, xml_node_set); xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set)); } break; case T_DATA: if(rb_obj_is_kind_of(result, cNokogiriXmlNodeSet)) { Data_Get_Struct(result, xmlNodeSet, xml_node_set); /* Copy the node set, otherwise it will get GC'd. */ xmlXPathReturnNodeSet(ctx, xmlXPathNodeSetMerge(NULL, xml_node_set)); break; } default: rb_raise(rb_eRuntimeError, "Invalid return type"); } }
STATIC VALUE rb_read_number(ramf0_load_context_t* context) { return rb_float_new(c_read_number(context)); }
static VALUE rb_grn_bulk_to_ruby_object_by_range_type (grn_ctx *context, grn_obj *bulk, grn_obj *range, grn_id range_id, VALUE related_object, VALUE *rb_value) { rb_grn_boolean success = RB_GRN_TRUE; if (!range && range_id != GRN_ID_NIL) { range = grn_ctx_at(context, range_id); } if (!range) return RB_GRN_FALSE; switch (range->header.type) { case GRN_TABLE_HASH_KEY: case GRN_TABLE_PAT_KEY: case GRN_TABLE_NO_KEY: { grn_id id; id = *((grn_id *)GRN_BULK_HEAD(bulk)); if (id == GRN_ID_NIL) { *rb_value = Qnil; } else { VALUE rb_range; rb_range = GRNOBJECT2RVAL(Qnil, context, range, RB_GRN_FALSE); *rb_value = rb_grn_record_new(rb_range, id, Qnil); } } break; case GRN_TYPE: if (range->header.flags & GRN_OBJ_KEY_VAR_SIZE) { *rb_value = rb_grn_context_rb_string_new(context, GRN_BULK_HEAD(bulk), GRN_BULK_VSIZE(bulk)); } else { switch (range->header.flags & GRN_OBJ_KEY_MASK) { case GRN_OBJ_KEY_UINT: *rb_value = INT2NUM(GRN_UINT32_VALUE(bulk)); break; case GRN_OBJ_KEY_INT: *rb_value = INT2NUM(GRN_INT32_VALUE(bulk)); break; case GRN_OBJ_KEY_FLOAT: *rb_value = rb_float_new(GRN_FLOAT_VALUE(bulk)); break; default: success = RB_GRN_FALSE; } break; } break; default: success = RB_GRN_FALSE; break; } return success; }
/** * call-seq: * UCalendar.now * * Get the current date and time. in millis * * UCalendar.now # => 1137934561000.0 * */ VALUE icu4r_cal_now(VALUE obj){ return rb_float_new(ucal_getNow()); }
static VALUE t_to_linear(VALUE self, VALUE f) { return rb_float_new(melinv(NUM2DBL(f))); }
VALUE cIGraph_community_spinglass(VALUE self, VALUE weights, VALUE spins, VALUE parupdate, VALUE starttemp, VALUE stoptemp, VALUE coolfact, VALUE update_rule, VALUE gamma){ igraph_t *graph; igraph_vector_t weights_vec; igraph_vector_t membership; igraph_real_t temperature; igraph_real_t modularity; igraph_bool_t parupdate_b; VALUE group; VALUE groups; VALUE res; VALUE str; int i,groupid,max_groupid; if(parupdate) parupdate_b = 1; Data_Get_Struct(self, igraph_t, graph); igraph_vector_init(&membership,0); igraph_vector_init(&weights_vec,RARRAY_LEN(weights)); for(i=0;i<RARRAY_LEN(weights);i++){ VECTOR(weights_vec)[i] = NUM2DBL(RARRAY_PTR(weights)[i]); } igraph_community_spinglass(graph, igraph_vector_size(&weights_vec) > 0 ? &weights_vec : NULL, &modularity,&temperature, &membership,NULL,NUM2INT(spins),parupdate_b, NUM2DBL(starttemp),NUM2DBL(stoptemp), NUM2DBL(coolfact),NUM2INT(update_rule), NUM2DBL(gamma)); max_groupid = 0; for(i=0;i<igraph_vector_size(&membership);i++){ if(VECTOR(membership)[i] > max_groupid) max_groupid = VECTOR(membership)[i]; } groups = rb_ary_new(); for(i=0;i<max_groupid+1;i++){ rb_ary_push(groups,rb_ary_new()); } for(i=0;i<igraph_vector_size(&membership);i++){ groupid = VECTOR(membership)[i]; if(groupid == -1) groupid = 0; group = RARRAY_PTR(groups)[groupid]; rb_ary_push(group,cIGraph_get_vertex_object(self, i)); } res = rb_ary_new3(3,groups, rb_float_new(modularity), rb_float_new(temperature)); igraph_vector_destroy(&membership); igraph_vector_destroy(&weights_vec); return res; }
VALUE rb_num_sqrt( VALUE num) { return rb_float_new( sqrt( RFLOAT_VALUE( rb_Float( num)))); }
VALUE cIGraph_community_leading_eigenvector_step(VALUE self, VALUE membership, VALUE community){ igraph_t *graph; igraph_vector_t membership_vec; igraph_vector_t eigenvector; igraph_real_t eigenvalue; igraph_bool_t split; int i,j,groupid,max_groupid,vid; igraph_arpack_options_t arpack_opt; igraph_arpack_options_init(&arpack_opt); VALUE groups, group, res, eigenvector_a, obj; Data_Get_Struct(self, igraph_t, graph); igraph_vector_init(&membership_vec,igraph_vcount(graph)); igraph_vector_init(&eigenvector,0); for(i=0;i<RARRAY_LEN(membership);i++){ group = RARRAY_PTR(membership)[i]; for(j=0;j<RARRAY_LEN(group);j++){ obj = RARRAY_PTR(group)[j]; vid = cIGraph_get_vertex_id(self,obj); VECTOR(membership_vec)[vid] = i; } } igraph_community_leading_eigenvector_step(graph,&membership_vec, NUM2INT(community), &split,&eigenvector,&eigenvalue,&arpack_opt,NULL); max_groupid = 0; for(i=0;i<igraph_vector_size(&membership_vec);i++){ if(VECTOR(membership_vec)[i] > max_groupid) max_groupid = VECTOR(membership_vec)[i]; } groups = rb_ary_new(); for(i=0;i<max_groupid+1;i++){ rb_ary_push(groups,rb_ary_new()); } for(i=0;i<igraph_vector_size(&membership_vec);i++){ groupid = VECTOR(membership_vec)[i]; if(groupid == -1) groupid = 0; group = RARRAY_PTR(groups)[groupid]; rb_ary_push(group,cIGraph_get_vertex_object(self, i)); } eigenvector_a = rb_ary_new(); for(i=0;i<igraph_vector_size(&eigenvector);i++){ rb_ary_push(eigenvector_a,rb_float_new(VECTOR(eigenvector)[i])); } res = rb_ary_new3(4,groups,split==0 ? Qfalse : Qtrue, eigenvector_a,rb_float_new(eigenvalue)); igraph_vector_destroy(&membership_vec); igraph_vector_destroy(&eigenvector); return res; }
static VALUE create_parameters_ary_gencan(ool_conmin_gencan_parameters *Pg) { VALUE ary; ary = rb_ary_new2(31); rb_ary_store(ary, 0, rb_float_new(Pg->epsgpen)); rb_ary_store(ary, 1, rb_float_new(Pg->epsgpsn)); rb_ary_store(ary, 2, rb_float_new(Pg->fmin)); rb_ary_store(ary, 3, rb_float_new(Pg->udelta0)); rb_ary_store(ary, 4, rb_float_new(Pg->ucgmia)); rb_ary_store(ary, 5, rb_float_new(Pg->ucgmib)); rb_ary_store(ary, 6, INT2FIX(Pg->cg_scre)); rb_ary_store(ary, 7, rb_float_new(Pg->cg_gpnf)); rb_ary_store(ary, 8, rb_float_new(Pg->cg_epsi)); rb_ary_store(ary, 9, rb_float_new(Pg->cg_epsf)); rb_ary_store(ary, 10, rb_float_new(Pg->cg_epsnqmp)); rb_ary_store(ary, 11, INT2FIX((int) Pg->cg_maxitnqmp)); rb_ary_store(ary, 12, INT2FIX(Pg->nearlyq)); rb_ary_store(ary, 13, rb_float_new(Pg->nint)); rb_ary_store(ary, 14, rb_float_new(Pg->next)); rb_ary_store(ary, 15, INT2FIX((int)Pg->mininterp)); rb_ary_store(ary, 16, INT2FIX((int)Pg->maxextrap)); rb_ary_store(ary, 17, INT2FIX(Pg->trtype)); rb_ary_store(ary, 18, rb_float_new(Pg->eta)); rb_ary_store(ary, 19, rb_float_new(Pg->delmin)); rb_ary_store(ary, 20, rb_float_new(Pg->lspgmi)); rb_ary_store(ary, 21, rb_float_new(Pg->lspgma)); rb_ary_store(ary, 22, rb_float_new(Pg->theta)); rb_ary_store(ary, 23, rb_float_new(Pg->gamma)); rb_ary_store(ary, 24, rb_float_new(Pg->beta)); rb_ary_store(ary, 25, rb_float_new(Pg->sigma1)); rb_ary_store(ary, 26, rb_float_new(Pg->sigma2)); rb_ary_store(ary, 27, rb_float_new(Pg->epsrel)); rb_ary_store(ary, 28, rb_float_new(Pg->epsabs)); rb_ary_store(ary, 29, rb_float_new(Pg->infrel)); rb_ary_store(ary, 30, rb_float_new(Pg->infabs)); return ary; }
static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool, int cast, MYSQL_FIELD * fields) { VALUE rowVal; mysql2_result_wrapper * wrapper; MYSQL_ROW row; unsigned int i = 0; unsigned long * fieldLengths; void * ptr; #ifdef HAVE_RUBY_ENCODING_H rb_encoding *default_internal_enc; rb_encoding *conn_enc; #endif GetMysql2Result(self, wrapper); #ifdef HAVE_RUBY_ENCODING_H default_internal_enc = rb_default_internal_encoding(); conn_enc = rb_to_encoding(wrapper->encoding); #endif ptr = wrapper->result; row = (MYSQL_ROW)rb_thread_blocking_region(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0); if (row == NULL) { return Qnil; } if (asArray) { rowVal = rb_ary_new2(wrapper->numberOfFields); } else { rowVal = rb_hash_new(); } fieldLengths = mysql_fetch_lengths(wrapper->result); if (wrapper->fields == Qnil) { wrapper->numberOfFields = mysql_num_fields(wrapper->result); wrapper->fields = rb_ary_new2(wrapper->numberOfFields); } for (i = 0; i < wrapper->numberOfFields; i++) { VALUE field = rb_mysql_result_fetch_field(self, i, symbolizeKeys); if (row[i]) { VALUE val = Qnil; enum enum_field_types type = fields[i].type; if(!cast) { if (type == MYSQL_TYPE_NULL) { val = Qnil; } else { val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif } } else { switch(type) { case MYSQL_TYPE_NULL: // NULL-type field val = Qnil; break; case MYSQL_TYPE_BIT: // BIT field (MySQL 5.0.3 and up) val = rb_str_new(row[i], fieldLengths[i]); break; case MYSQL_TYPE_TINY: // TINYINT field if (castBool && fields[i].length == 1) { val = *row[i] == '1' ? Qtrue : Qfalse; break; } case MYSQL_TYPE_SHORT: // SMALLINT field case MYSQL_TYPE_LONG: // INTEGER field case MYSQL_TYPE_INT24: // MEDIUMINT field case MYSQL_TYPE_LONGLONG: // BIGINT field case MYSQL_TYPE_YEAR: // YEAR field val = rb_cstr2inum(row[i], 10); break; case MYSQL_TYPE_DECIMAL: // DECIMAL or NUMERIC field case MYSQL_TYPE_NEWDECIMAL: // Precision math DECIMAL or NUMERIC field (MySQL 5.0.3 and up) if (fields[i].decimals == 0) { val = rb_cstr2inum(row[i], 10); } else if (strtod(row[i], NULL) == 0.000000){ val = rb_funcall(cBigDecimal, intern_new, 1, opt_decimal_zero); }else{ val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i])); } break; case MYSQL_TYPE_FLOAT: // FLOAT field case MYSQL_TYPE_DOUBLE: { // DOUBLE or REAL field double column_to_double; column_to_double = strtod(row[i], NULL); if (column_to_double == 0.000000){ val = opt_float_zero; }else{ val = rb_float_new(column_to_double); } break; } case MYSQL_TYPE_TIME: { // TIME field int hour, min, sec, tokens; tokens = sscanf(row[i], "%2d:%2d:%2d", &hour, &min, &sec); val = rb_funcall(rb_cTime, db_timezone, 6, opt_time_year, opt_time_month, opt_time_month, INT2NUM(hour), INT2NUM(min), INT2NUM(sec)); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { // utc val = rb_funcall(val, intern_utc, 0); } } break; } case MYSQL_TYPE_TIMESTAMP: // TIMESTAMP field case MYSQL_TYPE_DATETIME: { // DATETIME field unsigned int year, month, day, hour, min, sec, tokens; uint64_t seconds; tokens = sscanf(row[i], "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec); seconds = (year*31557600ULL) + (month*2592000ULL) + (day*86400ULL) + (hour*3600ULL) + (min*60ULL) + sec; if (seconds == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { if (seconds < MYSQL2_MIN_TIME || seconds > MYSQL2_MAX_TIME) { // use DateTime instead VALUE offset = INT2NUM(0); if (db_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); } val = rb_funcall(cDateTime, intern_civil, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), offset); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { offset = rb_funcall(cMysql2Client, intern_local_offset, 0); val = rb_funcall(val, intern_new_offset, 1, offset); } else { // utc val = rb_funcall(val, intern_new_offset, 1, opt_utc_offset); } } } else { val = rb_funcall(rb_cTime, db_timezone, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)); if (!NIL_P(app_timezone)) { if (app_timezone == intern_local) { val = rb_funcall(val, intern_localtime, 0); } else { // utc val = rb_funcall(val, intern_utc, 0); } } } } } break; } case MYSQL_TYPE_DATE: // DATE field case MYSQL_TYPE_NEWDATE: { // Newer const used > 5.0 int year, month, day, tokens; tokens = sscanf(row[i], "%4d-%2d-%2d", &year, &month, &day); if (year+month+day == 0) { val = Qnil; } else { if (month < 1 || day < 1) { rb_raise(cMysql2Error, "Invalid date: %s", row[i]); val = Qnil; } else { val = rb_funcall(cDate, intern_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day)); } } break; } case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_BLOB: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_VARCHAR: case MYSQL_TYPE_STRING: // CHAR or BINARY field case MYSQL_TYPE_SET: // SET field case MYSQL_TYPE_ENUM: // ENUM field case MYSQL_TYPE_GEOMETRY: // Spatial fielda default: val = rb_str_new(row[i], fieldLengths[i]); #ifdef HAVE_RUBY_ENCODING_H val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc); #endif break; } } if (asArray) { rb_ary_push(rowVal, val); } else { rb_hash_aset(rowVal, field, val); } } else { if (asArray) { rb_ary_push(rowVal, Qnil); } else { rb_hash_aset(rowVal, field, Qnil); } } } return rowVal; }
/* * call-seq: * evaluate(search_path, handler = nil) * * Evaluate the +search_path+ returning an XML::XPath object. */ static VALUE evaluate(int argc, VALUE *argv, VALUE self) { VALUE search_path, xpath_handler; VALUE thing = Qnil; xmlXPathContextPtr ctx; xmlXPathObjectPtr xpath; xmlChar *query; Data_Get_Struct(self, xmlXPathContext, ctx); if(rb_scan_args(argc, argv, "11", &search_path, &xpath_handler) == 1) xpath_handler = Qnil; query = (xmlChar *)StringValuePtr(search_path); if(Qnil != xpath_handler) { /* FIXME: not sure if this is the correct place to shove private data. */ ctx->userData = (void *)xpath_handler; xmlXPathRegisterFuncLookup(ctx, lookup, (void *)xpath_handler); } xmlResetLastError(); xmlSetStructuredErrorFunc(NULL, xpath_exception_handler); /* For some reason, xmlXPathEvalExpression will blow up with a generic error */ /* when there is a non existent function. */ xmlSetGenericErrorFunc(NULL, xpath_generic_exception_handler); xpath = xmlXPathEvalExpression(query, ctx); xmlSetStructuredErrorFunc(NULL, NULL); xmlSetGenericErrorFunc(NULL, NULL); if(xpath == NULL) { VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath")); VALUE klass = rb_const_get(xpath, rb_intern("SyntaxError")); xmlErrorPtr error = xmlGetLastError(); rb_exc_raise(Nokogiri_wrap_xml_syntax_error(klass, error)); } assert(ctx->doc); assert(DOC_RUBY_OBJECT_TEST(ctx->doc)); switch(xpath->type) { case XPATH_STRING: thing = NOKOGIRI_STR_NEW2(xpath->stringval); xmlFree(xpath->stringval); break; case XPATH_NODESET: if(NULL == xpath->nodesetval) { thing = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL), DOC_RUBY_OBJECT(ctx->doc)); } else { thing = Nokogiri_wrap_xml_node_set(xpath->nodesetval, DOC_RUBY_OBJECT(ctx->doc)); } break; case XPATH_NUMBER: thing = rb_float_new(xpath->floatval); break; case XPATH_BOOLEAN: thing = xpath->boolval == 1 ? Qtrue : Qfalse; break; default: thing = Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL), DOC_RUBY_OBJECT(ctx->doc)); } xmlXPathFreeNodeSetList(xpath); return thing; }
static void read_num(ParseInfo pi, const char *key) { char *start = pi->s; int64_t n = 0; long a = 0; long div = 1; long e = 0; int neg = 0; int eneg = 0; int big = 0; if ('-' == *pi->s) { pi->s++; neg = 1; } else if ('+' == *pi->s) { pi->s++; } if ('I' == *pi->s) { if (0 != strncmp("Infinity", pi->s, 8)) { if (pi->has_error) { call_error("number or other value", pi, __FILE__, __LINE__); } raise_error("number or other value", pi->str, pi->s); } pi->s += 8; if (neg) { if (pi->has_add_value) { call_add_value(pi->handler, rb_float_new(-OJ_INFINITY), key); } } else { if (pi->has_add_value) { call_add_value(pi->handler, rb_float_new(OJ_INFINITY), key); } } return; } for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) { if (big) { big++; } else { n = n * 10 + (*pi->s - '0'); if (NUM_MAX <= n) { big = 1; } } } if ('.' == *pi->s) { pi->s++; for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) { a = a * 10 + (*pi->s - '0'); div *= 10; if (NUM_MAX <= div) { big = 1; } } } if ('e' == *pi->s || 'E' == *pi->s) { pi->s++; if ('-' == *pi->s) { pi->s++; eneg = 1; } else if ('+' == *pi->s) { pi->s++; } for (; '0' <= *pi->s && *pi->s <= '9'; pi->s++) { e = e * 10 + (*pi->s - '0'); if (NUM_MAX <= e) { big = 1; } } } if (0 == e && 0 == a && 1 == div) { if (big) { char c = *pi->s; *pi->s = '\0'; if (pi->has_add_value) { call_add_value(pi->handler, rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(start)), key); } *pi->s = c; } else { if (neg) { n = -n; } if (pi->has_add_value) { call_add_value(pi->handler, LONG2NUM(n), key); } } return; } else { /* decimal */ if (big) { char c = *pi->s; *pi->s = '\0'; if (pi->has_add_value) { call_add_value(pi->handler, rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new2(start)), key); } *pi->s = c; } else { double d = (double)n + (double)a / (double)div; if (neg) { d = -d; } if (1 < big) { e += big - 1; } if (0 != e) { if (eneg) { e = -e; } d *= pow(10.0, e); } if (pi->has_add_value) { call_add_value(pi->handler, rb_float_new(d), key); } } } }
static void notmuch_rb_upgrade_notify(void *closure, double progress) { VALUE *block = (VALUE *)closure; rb_funcall(*block, ID_call, 1, rb_float_new(progress)); }
/* * Calculates a function at x, and returns the rusult. */ static VALUE rb_gsl_function_eval(VALUE obj, VALUE x) { gsl_function *F = NULL; VALUE ary, proc, params, result, arynew, x2; gsl_vector *v = NULL, *vnew = NULL; gsl_matrix *m = NULL, *mnew = NULL; size_t i, j, n; #ifdef HAVE_NARRAY_H double *ptr1, *ptr2; struct NARRAY *na; #endif Data_Get_Struct(obj, gsl_function, F); ary = (VALUE) F->params; proc = rb_ary_entry(ary, 0); params = rb_ary_entry(ary, 1); if (CLASS_OF(x) == rb_cRange) x = rb_gsl_range2ary(x); switch (TYPE(x)) { case T_FIXNUM: case T_BIGNUM: case T_FLOAT: if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x); else result = rb_funcall(proc, RBGSL_ID_call, 2, x, params); return result; break; case T_ARRAY: n = RARRAY(x)->len; arynew = rb_ary_new2(n); for (i = 0; i < n; i++) { x2 = rb_ary_entry(x, i); Need_Float(x2); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2); else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params); rb_ary_store(arynew, i, result); } return arynew; break; default: #ifdef HAVE_NARRAY_H if (NA_IsNArray(x)) { GetNArray(x, na); ptr1 = (double *) na->ptr; n = na->total; ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(x)); ptr2 = NA_PTR_TYPE(ary, double*); for (i = 0; i < n; i++) { x2 = rb_float_new(ptr1[i]); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2); else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params); ptr2[i] = NUM2DBL(result); } return ary; } #endif if (VECTOR_P(x)) { Data_Get_Struct(x, gsl_vector, v); vnew = gsl_vector_alloc(v->size); for (i = 0; i < v->size; i++) { x2 = rb_float_new(gsl_vector_get(v, i)); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2); else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params); gsl_vector_set(vnew, i, NUM2DBL(result)); } return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew); } else if (MATRIX_P(x)) { Data_Get_Struct(x, gsl_matrix, m); mnew = gsl_matrix_alloc(m->size1, m->size2); for (i = 0; i < m->size1; i++) { for (j = 0; j < m->size2; j++) { x2 = rb_float_new(gsl_matrix_get(m, i, j)); if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2); else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params); gsl_matrix_set(mnew, i, j, NUM2DBL(result)); } } return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew); } else { rb_raise(rb_eTypeError, "wrong argument type"); } break; } /* never reach here */ return Qnil; }