Exemple #1
0
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
}
Exemple #2
0
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");
  }
}
Exemple #4
0
/* 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);
}
Exemple #5
0
/*
 * 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);
}
Exemple #6
0
/* 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() );
}
Exemple #7
0
static VALUE t_to_mel(VALUE self, VALUE m) {
  return rb_float_new(mel(NUM2DBL(m)));
}
Exemple #8
0
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));
}
Exemple #9
0
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));
}
Exemple #10
0
static VALUE t_get_comm_inactivity_timeout (VALUE self UNUSED, VALUE signature)
{
	return rb_float_new(evma_get_comm_inactivity_timeout(NUM2BSIG (signature)));
}
Exemple #11
0
static VALUE t_get_pending_connect_timeout (VALUE self UNUSED, VALUE signature)
{
	return rb_float_new(evma_get_pending_connect_timeout(NUM2BSIG (signature)));
}
Exemple #12
0
static VALUE t_get_heartbeat_interval (VALUE self UNUSED)
{
	return rb_float_new(evma_get_heartbeat_interval());
}
Exemple #13
0
/*
 * 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));
}
Exemple #14
0
static VALUE
rb_cpBBGetT(VALUE self) {
  return rb_float_new(BBGET(self)->t);
}
Exemple #15
0
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

}
Exemple #16
0
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");
  }
}
Exemple #18
0
STATIC VALUE rb_read_number(ramf0_load_context_t* context)
{
  return rb_float_new(c_read_number(context));
}
Exemple #19
0
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;
}
Exemple #20
0
/**
 * 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());
}
Exemple #21
0
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;

}
Exemple #23
0
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;

}
Exemple #25
0
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;
}
Exemple #26
0
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;
}
Exemple #28
0
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);
	    }
	}
    }
}
Exemple #29
0
static void
notmuch_rb_upgrade_notify(void *closure, double progress)
{
    VALUE *block = (VALUE *)closure;
    rb_funcall(*block, ID_call, 1, rb_float_new(progress));
}
Exemple #30
0
/*
 * 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;
}