static VALUE geographiclib_local_cartesian_initialize(int argc, VALUE *argv, VALUE self)
{
GeographicLib::Math::real lat = 0.0, lon = 0.0, h = 0.0;
switch (argc) {
default:
rb_raise(rb_eArgError, "Wrong number of arguments. Expecting 0, 1, 2 or 3.");
case 3:
h = rb_num2dbl(argv[2]);
case 2:
decode_lat_lon(argv[0], argv[1], lat, lon);
case 0:
break;
case 1:
rb_check_type(argv[0], T_HASH);
decode_lat_lon(rb_hash_lookup(argv[0], rb_symbol("lat")), rb_hash_lookup(argv[0], rb_symbol("lon")), lat, lon);
VALUE vh = rb_hash_lookup(argv[0], rb_symbol("h"));
if (vh != Qnil) {
h = rb_num2dbl(vh);
}
break;
}
geographiclib_local_cartesian_free(DATA_PTR(self));
DATA_PTR(self) = new GeographicLib::LocalCartesian(lat, lon, h);
return self;
}
static VALUE geographiclib_local_cartesian_forward(int argc, VALUE *argv, VALUE self)
{
GeographicLib::Math::real lat = 0.0, lon = 0.0, h = 0.0, x, y, z;
switch (argc) {
default:
rb_raise(rb_eArgError, "Wrong number of arguments. Expecting 1, 2 or 3.");
case 3:
h = rb_num2dbl(argv[2]);
case 2:
decode_lat_lon(argv[0], argv[1], lat, lon);
break;
case 1:
rb_check_type(argv[0], T_HASH);
decode_lat_lon(rb_hash_lookup(argv[0], rb_symbol("lat")), rb_hash_lookup(argv[0], rb_symbol("lon")), lat, lon);
VALUE vh = rb_hash_lookup(argv[0], rb_symbol("h"));
if (vh != Qnil) {
h = rb_num2dbl(vh);
}
break;
}
GeographicLib::LocalCartesian *lc = geographiclib_local_cartesian_get(self);
lc->Forward(lat, lon, h, x, y, z);
VALUE r = rb_hash_new();
rb_hash_aset(r, rb_symbol("x"), rb_float_new(x));
rb_hash_aset(r, rb_symbol("y"), rb_float_new(y));
rb_hash_aset(r, rb_symbol("z"), rb_float_new(z));
return r;
}
static VALUE cmethod_proj4_transform(VALUE module, VALUE from, VALUE to, VALUE x, VALUE y, VALUE z)
{
VALUE result;
projPJ from_pj;
projPJ to_pj;
double xval, yval, zval;
int err;
result = Qnil;
from_pj = RGEO_PROJ4_DATA_PTR(from)->pj;
to_pj = RGEO_PROJ4_DATA_PTR(to)->pj;
if (from_pj && to_pj) {
xval = rb_num2dbl(x);
yval = rb_num2dbl(y);
zval = 0.0;
if (!NIL_P(z)) {
zval = rb_num2dbl(z);
}
err = pj_transform(from_pj, to_pj, 1, 1, &xval, &yval, NIL_P(z) ? NULL : &zval);
if (!err && xval != HUGE_VAL && yval != HUGE_VAL && (NIL_P(z) || zval != HUGE_VAL)) {
result = rb_ary_new2(NIL_P(z) ? 2 : 3);
rb_ary_push(result, rb_float_new(xval));
rb_ary_push(result, rb_float_new(yval));
if (!NIL_P(z)) {
rb_ary_push(result, rb_float_new(zval));
}
}
}
return result;
}
static void decode_lat_lon(VALUE vlat, VALUE vlon, GeographicLib::Math::real &lat, GeographicLib::Math::real &lon)
{
std::string slat, slon;
if (rb_type(vlat) == T_STRING && rb_type(vlon) == T_STRING) {
slat = rb_string_value_cstr(&vlat);
slon = rb_string_value_cstr(&vlon);
try {
GeographicLib::DMS::DecodeLatLon(slat, slon, lat, lon);
} catch (GeographicLib::GeographicErr e) {
rb_raise(rb_eRuntimeError, "This is not a valid position.");
}
} else {
lat = rb_num2dbl(vlat);
lon = rb_num2dbl(vlon);
}
}
static int foreach_array(VALUE key, VALUE val, struct Shape * shape)
{
int array_type = 0;
if (TYPE(key) == T_FIXNUM) array_type = NUM2INT(key);
else if (TYPE(key) == T_STRING) array_type = atoi(RSTRING_PTR(key));
if (shape == NULL || (long)shape == Qnil) { fprintf(stderr, "foreach_array expects a shape, provided NULL\n"); return 0; }
VALUE vertexs = rb_hash_aref(val, ENCODED_STR_NEW2("vertexs", "ASCII-8BIT"));
long int num_vertexs = RARRAY_LEN(vertexs);
if (shape->num_vertexs != 0 && shape->num_vertexs != num_vertexs) { fprintf(stderr, "foreach_array received an array with %ld vertexs, however the shape had %d vertexs. (They should be the same)\n", RARRAY_LEN(vertexs), shape->num_vertexs); return 0; }
int num_dimensions = NUM2INT(rb_hash_aref(val, ENCODED_STR_NEW2("num_dimensions", "ASCII-8BIT")));
float f[4] = {0,0,0,0};
int i;
for (i = 0 ; i < RARRAY_LEN(vertexs) ; i++)
{
VALUE v = rb_ary_entry(vertexs, i);
int j = 0;
for (j = 0 ; j < num_dimensions ; j++)
f[j] = (float)rb_num2dbl(rb_ary_entry(v, j));
append_vertex(shape, f);
}
return 0;
}
/**
* call-seq:
* calendar.millis = new_value
*
* Sets calendar's value in milliseconds.
*/
VALUE icu4r_cal_set_millis(VALUE obj,VALUE milli)
{
UErrorCode status = U_ZERO_ERROR;
Check_Type(milli, T_FLOAT);
ucal_setMillis(UCALENDAR(obj), rb_num2dbl(milli), &status);
ICU_RAISE(status);
return Qnil;
}
static inline uint64_t
rb_num2nsec(VALUE num)
{
const double sec = rb_num2dbl(num);
if (sec < 0.0) {
rb_raise(rb_eArgError, "negative delay specified");
}
return SEC2NSEC_UINT64(sec);
}
double calculate_total_distance_from_mean(VALUE array, unsigned long array_length){
unsigned long i;
double total = 0;
double mean = 0;
double total_distance_from_mean = 0;
for(i = 0; i < array_length; i++){
total += rb_num2dbl(rb_ary_entry(array, i));
}
mean = total / array_length;
for(i = 0; i < array_length; i++){
total_distance_from_mean += pow((rb_num2dbl(rb_ary_entry(array, i)) - mean), 2);
}
return total_distance_from_mean;
}
long double
rbffi_num2longdouble(VALUE value)
{
if (TYPE(value) == T_FLOAT) {
return rb_num2dbl(value);
}
if (!RTEST(rb_cBigDecimal) && rb_const_defined(rb_cObject, rb_intern("BigDecimal"))) {
rb_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
}
if (RTEST(rb_cBigDecimal) && rb_cBigDecimal != rb_cObject && RTEST(rb_obj_is_kind_of(value, rb_cBigDecimal))) {
VALUE s = rb_funcall(value, rb_intern("to_s"), 1, rb_str_new2("E"));
return strtold(RSTRING_PTR(s), NULL);
}
/* Fall through to handling as a float */
return rb_num2dbl(value);
}
static OCIAnyData *
to_return_value(plruby_context_t *ctx, VALUE val)
{
OCIAnyData *sdata = NULL;
OCIInd ind = OCI_IND_NOTNULL;
if (NIL_P(val)) {
return NULL;
}
switch (ctx->rettype) {
case OCI_TYPECODE_VARCHAR2:
{
OCIString *str = NULL;
VALUE sval = rb_String(val);
sval = rb_str_export_to_enc(sval, oracle_encoding);
chk(OCIStringAssignText(ctx->envhp, ctx->errhp, (text*)RSTRING_PTR(sval), RSTRING_LEN(sval), &str));
chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, str, 0, &sdata));
chk(OCIStringResize(ctx->envhp, ctx->errhp, 0, &str));
return sdata;
}
case OCI_TYPECODE_NUMBER:
{
OCINumber num;
double dval = rb_num2dbl(val);
chk(OCINumberFromReal(ctx->errhp, &dval, sizeof(dval), &num));
chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, &num, 0, &sdata));
return sdata;
}
case OCI_TYPECODE_BDOUBLE:
{
double dval = rb_num2dbl(val);
chk(OCIAnyDataConvert(ctx->svchp, ctx->errhp, ctx->rettype, NULL, OCI_DURATION_SESSION, &ind, &dval, 0, &sdata));
return sdata;
}
}
rb_raise(rb_eRuntimeError, "Unsupported Typecode %d", ctx->rettype);
}
static inline dispatch_time_t
rb_num2timeout(VALUE num)
{
dispatch_time_t dispatch_timeout = DISPATCH_TIME_FOREVER;
if (!NIL_P(num)) {
const double sec = rb_num2dbl(num);
if (sec < TIMEOUT_MAX) {
dispatch_timeout = dispatch_walltime(NULL, SEC2NSEC_INT64(sec));
}
}
return dispatch_timeout;
}
static VALUE geographiclib_geodesic_inverse(VALUE self, VALUE a, VALUE f, VALUE vlat1, VALUE vlon1, VALUE vlat2, VALUE vlon2)
{
GeographicLib::Geodesic g(rb_num2dbl(a), rb_num2dbl(f));
GeographicLib::Math::real lat1, lon1, lat2, lon2, s12, azi1, azi2, m12, M12, M21, S12;
decode_lat_lon(vlat1, vlon1, lat1, lon1);
decode_lat_lon(vlat2, vlon2, lat2, lon2);
g.GenInverse(lat1, lon1, lat2, lon2, GeographicLib::Geodesic::ALL, s12, azi1, azi2, m12, M12, M21, S12);
VALUE r = rb_hash_new();
rb_hash_aset(r, rb_symbol("lat1"), rb_float_new(lat1));
rb_hash_aset(r, rb_symbol("lon1"), rb_float_new(lon1));
rb_hash_aset(r, rb_symbol("lat2"), rb_float_new(lat2));
rb_hash_aset(r, rb_symbol("lon2"), rb_float_new(lon2));
rb_hash_aset(r, rb_symbol("s12"), rb_float_new(s12));
rb_hash_aset(r, rb_symbol("azi1"), rb_float_new(azi1));
rb_hash_aset(r, rb_symbol("azi2"), rb_float_new(azi2));
rb_hash_aset(r, rb_symbol("m12"), rb_float_new(m12));
rb_hash_aset(r, rb_symbol("M12"), rb_float_new(M12));
rb_hash_aset(r, rb_symbol("M21"), rb_float_new(M21));
rb_hash_aset(r, rb_symbol("S12"), rb_float_new(S12));
return r;
}
static VALUE geographiclib_local_cartesian_reverse(int argc, VALUE *argv, VALUE self)
{
GeographicLib::Math::real lat, lon, h, x, y, z = 0.0;
switch (argc) {
default:
rb_raise(rb_eArgError, "Wrong number of arguments. Expecting 1 or 3.");
case 3:
x = rb_num2dbl(argv[0]);
y = rb_num2dbl(argv[1]);
z = rb_num2dbl(argv[2]);
break;
case 1:
rb_check_type(argv[0], T_HASH);
x = rb_num2dbl(rb_hash_lookup(argv[0], rb_symbol("x")));
y = rb_num2dbl(rb_hash_lookup(argv[0], rb_symbol("y")));
z = rb_num2dbl(rb_hash_lookup(argv[0], rb_symbol("z")));
break;
}
GeographicLib::LocalCartesian *lc = geographiclib_local_cartesian_get(self);
lc->Reverse(x, y, z, lat, lon, h);
VALUE r = rb_hash_new();
rb_hash_aset(r, rb_symbol("lat"), rb_float_new(lat));
rb_hash_aset(r, rb_symbol("lon"), rb_float_new(lon));
rb_hash_aset(r, rb_symbol("h"), rb_float_new(h));
return r;
}
static void decode_azi(VALUE vazi, GeographicLib::Math::real &azi)
{
std::string sazi;
if (rb_type(vazi) == T_STRING) {
sazi = rb_string_value_cstr(&vazi);
try {
azi = GeographicLib::DMS::DecodeAzimuth(sazi);
} catch (GeographicLib::GeographicErr e) {
rb_raise(rb_eRuntimeError, "This is not a valid azimuth.");
}
} else {
azi = rb_num2dbl(vazi);
}
}
static VALUE method_geometry_simplify(VALUE self, VALUE tolerance)
{
VALUE result;
RGeo_GeometryData* self_data;
const GEOSGeometry* self_geom;
VALUE factory;
result = Qnil;
self_data = RGEO_GEOMETRY_DATA_PTR(self);
self_geom = self_data->geom;
if (self_geom) {
factory = self_data->factory;
result = rgeo_wrap_geos_geometry(factory, GEOSSimplify_r(self_data->geos_context, self_geom,
rb_num2dbl(tolerance)), Qnil);
}
return result;
}
static void pack_value_object(msgpack_packer *packer, VALUE value) {
VALUE rubyString;
char *keyString;
switch (TYPE(value)) {
case T_FIXNUM:
msgpack_pack_long(packer, FIX2LONG(value));
break;
case T_FLOAT:
msgpack_pack_double(packer, rb_num2dbl(value));
break;
default:
rubyString = rb_funcall(value, rb_intern("to_s"), 0, 0);
keyString = StringValueCStr(rubyString);
pack_string(packer, keyString);
break;
}
}
static VALUE method_geometry_buffer(VALUE self, VALUE distance)
{
VALUE result;
RGeo_GeometryData* self_data;
const GEOSGeometry* self_geom;
VALUE factory;
int resolution;
result = Qnil;
self_data = RGEO_GEOMETRY_DATA_PTR(self);
self_geom = self_data->geom;
if (self_geom) {
factory = self_data->factory;
result = rgeo_wrap_geos_geometry(factory, GEOSBuffer_r(self_data->geos_context, self_geom,
rb_num2dbl(distance), RGEO_FACTORY_DATA_PTR(factory)->buffer_resolution), Qnil);
}
return result;
}
static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE z)
{
return rgeo_create_geos_point(factory, rb_num2dbl(x), rb_num2dbl(y),
RGEO_FACTORY_DATA_PTR(factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M ? rb_num2dbl(z) : 0);
}
/*
* Document-method: Float#to_msgpack
*
* call-seq:
* float.to_msgpack(out = '') -> String
*
* Serializes the Float into raw bytes.
*/
static VALUE MessagePack_Float_to_msgpack(int argc, VALUE *argv, VALUE self)
{
ARG_BUFFER(out, argc, argv);
msgpack_pack_double(out, rb_num2dbl(self));
return out;
}
bp::Object *
rubyToBPObject(VALUE v)
{
bp::Object * obj = NULL;
switch (TYPE(v)) {
case T_FLOAT:
obj = new bp::Double(rb_num2dbl(v));
break;
case T_STRING:
obj = new bp::String(RSTRING_PTR(v));
break;
case T_FIXNUM:
obj = new bp::Integer(rb_num2ull(v));
break;
case T_TRUE:
obj = new bp::Bool(true);
break;
case T_FALSE:
obj = new bp::Bool(false);
break;
case T_HASH:
obj = new bp::Map;
rb_hash_foreach(v,
(int (*)(ANYARGS)) hashPopulator,
(VALUE) obj);
break;
case T_ARRAY:
{
long i;
bp::List * l = new bp::List;
for (i=0; i < RARRAY_LEN(v); i++) {
l->append(rubyToBPObject(rb_ary_entry(v, i)));
}
obj = l;
}
break;
case T_OBJECT: {
// map Pathname objects into BPTPath types
VALUE id = rb_intern("Pathname");
VALUE klass = 0;
if (rb_const_defined(rb_cObject, id) &&
(klass = rb_const_get(rb_cObject, id)) &&
TYPE(klass) == T_CLASS)
{
VALUE r = rb_obj_is_kind_of(v, klass);
if (RTEST(r)) {
// convert to abs path
int error = 0;
VALUE absPath =
ruby::invokeFunction(v, "realpath", &error, 0);
VALUE pathString =
ruby::invokeFunction(absPath, "to_s", &error, 0);
if (!error && TYPE(pathString) == T_STRING) {
obj = new bp::Path((const BPPath) convert::fromUTF8(RSTRING_PTR(pathString)).c_str());
}
break;
}
}
}
case T_NIL:
default:
obj = new bp::Null();
break;
}
return obj;
}
static VALUE numeric_spec_rb_num2dbl(VALUE self, VALUE num) {
return rb_float_new(rb_num2dbl(num));
}
/*
Static: check_num2dbl
Purpose: return 0 if rb_num2dbl doesn't raise an exception
*/
static VALUE
check_num2dbl(VALUE obj)
{
(void) rb_num2dbl(obj);
return INT2FIX(1);
}
