ERL_NIF_TERM _hh_percentile(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
double percentile;
hh_ctx_t* ctx = NULL;
ErlNifResourceType* ctx_type = get_hh_ctx_type(env);
if (argc != 2 ||
ctx_type == NULL ||
!enif_get_resource(env, argv[0], ctx_type, (void **)&ctx) ||
!enif_get_double(env, argv[1], &percentile))
{
return enif_make_badarg(env);
}
if (ctx != NULL)
{
if (ctx->data->total_count == 0)
{
return enif_make_double(env, 0.);
}
else
{
return enif_make_double(
env,
round_to_significant_figures(
hdr_value_at_percentile(ctx->data,percentile),
ctx->significant_figures
)
);
}
}
return make_error(env, "bad_hdr_histogram_nif_impl");
}
ERL_NIF_TERM
geom_to_eterm_point_coords(ErlNifEnv *env, const GEOSGeometry *geom)
{
const GEOSCoordSequence *coords_seq;
double coordx, coordy;
coords_seq = GEOSGeom_getCoordSeq(geom);
GEOSCoordSeq_getX(coords_seq, 0, &coordx);
GEOSCoordSeq_getY(coords_seq, 0, &coordy);
return enif_make_list2(env, enif_make_double(env, coordx),
enif_make_double(env, coordy));
}
static ERL_NIF_TERM get_imginfo(ErlNifEnv* env, GDALDatasetH out_ds) {
double padfTransform[6];
GDALGetGeoTransform(out_ds, padfTransform);
if (padfTransform[2] != 0.0 && padfTransform[4] != 0.0) {
return ATOM_ERROR;
}
return enif_make_tuple6(env,
enif_make_double(env, padfTransform[0]), // OriginX
enif_make_double(env, padfTransform[3]), // OriginY
enif_make_double(env, padfTransform[1]), // PixelXSize
enif_make_double(env, padfTransform[5]), // PixelYSize
enif_make_int(env, GDALGetRasterXSize(out_ds)), // RasterXSize
enif_make_int(env, GDALGetRasterYSize(out_ds)));// RasterYSize
}
static ERL_NIF_TERM mruby2erl(ErlNifEnv* env, mrb_state* mrb, mrb_value value) {
if (mrb_nil_p(value)) {
return enif_make_atom(env, "nil");
} else {
switch(value.tt) {
case MRB_TT_TRUE:
return enif_make_atom(env, "true");
case MRB_TT_FALSE:
return enif_make_atom(env, "false");
case MRB_TT_SYMBOL:
return enif_make_atom(env, _mrb_symbol(mrb, value));
case MRB_TT_FIXNUM:
return enif_make_int(env, _mrb_fixnum(value));
case MRB_TT_FLOAT:
return enif_make_double(env, _mrb_float(value));
case MRB_TT_STRING:
return make_binary(env, _mrb_string(mrb, value));
case MRB_TT_ARRAY:
return make_array(env, mrb, value);
case MRB_TT_HASH:
return make_hash(env, mrb, value);
default :
return enif_make_atom(env, "nil");
}
}
}
static ERL_NIF_TERM variance(ErlNifEnv * env, int argc, const ERL_NIF_TERM argv[]) {
double_list dl = alloc_double_list(env, argv[0]);
ARG_ERROR_IF_DL_IS_NULL(dl);
ERL_NIF_TERM final = enif_make_double(env, gsl_stats_variance(dl.list, 1, dl.length));
free_double_list(dl);
return final;
}
/*-----------------------------------------------------------------------------------------------------------------------*/
static ERL_NIF_TERM get_double_field(ErlNifEnv* env, int32_t argc, ERL_NIF_TERM const argv[])
{
ERL_NIF_TERM parser_res;
ERL_NIF_TERM msg_res;
ERL_NIF_TERM group_res;
ParserRes* parser = NULL;
FIXMsg* msg = NULL;
FIXGroup* group = NULL;
ERL_NIF_TERM res = get_parser_msg_group(env, argv[0], &parser_res, &msg_res, &group_res, &parser, &msg, &group);
if (res != ok_atom)
{
return res;
}
int32_t tagNum = 0;
if (!enif_get_int(env, argv[1], &tagNum))
{
return make_error(env, FIX_FAILED, "Wrong tag num.");
}
double val = 0;
FIXError* error = NULL;
pthread_rwlock_rdlock(&parser->lock);
FIXErrCode err = fix_msg_get_double(msg, group, tagNum, &val, &error);
pthread_rwlock_unlock(&parser->lock);
if (err == FIX_FAILED)
{
ERL_NIF_TERM ret = make_parser_error(env, fix_error_get_code(error), fix_error_get_text(error));
fix_error_free(error);
return ret;
}
return enif_make_tuple2(env, ok_atom, enif_make_double(env, val));
}
static ERL_NIF_TERM make_scalar(ErlNifEnv* env, yaml_event_t *event, int flags)
{
int as_atom = PLAIN_AS_ATOM & flags;
long int i;
double d;
int type;
yaml_scalar_style_t style = event->data.scalar.style;
ERL_NIF_TERM rterm;
if (as_atom && style == YAML_SINGLE_QUOTED_SCALAR_STYLE) {
rterm = enif_make_atom_len(env,
(char *) event->data.scalar.value,
event->data.scalar.length);
} else if (style == YAML_DOUBLE_QUOTED_SCALAR_STYLE) {
rterm = make_binary_size(env, event->data.scalar.value,
event->data.scalar.length);
} else if ((type = make_num(env, event->data.scalar.value,
event->data.scalar.length, &i, &d))) {
if (type == INTEGER)
rterm = enif_make_long(env, i);
else
rterm = enif_make_double(env, d);
} else if (as_atom && style == YAML_PLAIN_SCALAR_STYLE && event->data.scalar.length) {
rterm = enif_make_atom_len(env,
(char *) event->data.scalar.value,
event->data.scalar.length);
} else {
rterm = make_binary_size(env, event->data.scalar.value,
event->data.scalar.length);
}
return rterm;
}
static ERL_NIF_TERM perspective(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
double fovy,aspect,zNear,zFar;
ERL_NIF_TERM d[16];
if(!enif_get_double(env,argv[0], &fovy)) {
return enif_make_badarg(env);
}
if(!enif_get_double(env,argv[1], &aspect)) {
return enif_make_badarg(env);
}
if(!enif_get_double(env,argv[2], &zNear)) {
return enif_make_badarg(env);
}
if(!enif_get_double(env,argv[3], &zFar)) {
return enif_make_badarg(env);
}
glm::dmat4 p = glm::perspective(fovy, aspect,zNear, zFar);
const double *pSource = (const double*)glm::value_ptr(p);
for( int i=0; i< 16; ++i)
d[i] = enif_make_double(env,pSource[i]);
return enif_make_tuple_from_array(env, d, 16);
}
static ERL_NIF_TERM evaluate_solution(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
// long diff;
// struct timespec start, end;
// clock_gettime(CLOCK_MONOTONIC, &start);
ErlNifResourceType* sol_type;
Solution* sol;
double fitness;
CHECK(env, argc == 1)
sol_type = (ErlNifResourceType*) enif_priv_data(env);
CHECK(env, sol_type)
CHECK(env, enif_get_resource(env, argv[0], sol_type, (void**) &sol))
#ifdef DEBUG
print_solution(sol,"Genotype");
#endif
fitness = fitness_rastrigin(sol);
// clock_gettime(CLOCK_MONOTONIC, &end);
// diff = CLOCKS_PER_SEC * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
// printf("eval=%llu\n", (long long unsigned int) diff);
return enif_make_double(env, fitness);
}
static ERL_NIF_TERM _compare(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
UNUSED(argc);
ErlNifBinary b1,b2;
int pos,minpos,step,min;
enif_inspect_binary(env,argv[0],&b1);
enif_inspect_binary(env,argv[1],&b2);
enif_get_int(env,argv[2],&pos);
enif_get_int(env,argv[3],&minpos);
enif_get_int(env,argv[4],&step);
enif_get_int(env,argv[5],&min);
double result = 0.0;
int startpos = pos;
while(pos>minpos){
int R = abs(b1.data[pos-2]-b2.data[pos-2]);
int G = abs(b1.data[pos-1]-b2.data[pos-1]);
int B = abs(b1.data[pos]-b2.data[pos]);
int M = R+G+B;
if(M >= min)
result += 1;
pos = pos-3*step;
}
return enif_make_double(env,result/((startpos-minpos)/step));
}
/* Currently support for 2 dimensions only */
ERL_NIF_TERM
GEOSCoordSequence_to_eterm_list(ErlNifEnv *env,
const GEOSCoordSequence *coords_seq, unsigned int len) {
int i = 0;
double coordx, coordy;
ERL_NIF_TERM coords_list[len];
ERL_NIF_TERM coords;
for(i=0; i<len; i++) {
GEOSCoordSeq_getX(coords_seq, i, &coordx);
GEOSCoordSeq_getY(coords_seq, i, &coordy);
coords = enif_make_list2(env, enif_make_double(env, coordx),
enif_make_double(env, coordy));
coords_list[i] = coords;
}
return enif_make_list_from_array(env, coords_list, len);
}
int
to_erl_float(ErlNifEnv* env, JSContext* cx, jsval val, ERL_NIF_TERM* term)
{
double rval;
if(!JS_ValueToNumber(cx, val, &rval)) return ERROR;
*term = enif_make_double(env, rval);
return OK;
}
ERL_NIF_TERM date_now(ErlNifEnv* env, int argc,
const ERL_NIF_TERM /*argv*/[])
{
if (argc != 0)
return enif_make_badarg(env);
return enif_make_double(env, (double) ucal_getNow());
}
/**
* Erlang Wrapper for geonum_decode
*/
ERL_NIF_TERM
erl_geonum_decode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
double point[2];
long long geonum;
if(!enif_get_int64(env, argv[0], &geonum)) {
return enif_make_badarg(env);
}
geonum_decode(geonum, point);
ERL_NIF_TERM point_tuple = enif_make_tuple2(env,
enif_make_double(env, point[0]),
enif_make_double(env, point[1]));
return make_ok(env, point_tuple);
}
static int test_double(ErlNifEnv* env, double d1)
{
double d2 = 0;
ERL_NIF_TERM term = enif_make_double(env, d1);
if (!enif_get_double(env,term, &d2) || d1 != d2) {
fprintf(stderr, "test_double(%e) ...FAILED i2=%e\r\n", d1, d2);
return 0;
}
return 1;
}
static bool
decode_visit_double(const bson_iter_t *iter,
const char *key,
double v_double,
void *data)
{
decode_state *ds = data;
ERL_NIF_TERM out = enif_make_double(ds->env, v_double);
vec_push(ds->vec, out);
return false;
}
ERL_NIF_TERM PCudaFloatBuffer::toErlTerms(ErlNifEnv *env) {
std::vector<double>::iterator iter;
ERL_NIF_TERM retval = enif_make_list(env, 0);
if (this->data->size() > 0) {
for (iter = this->data->end(); iter != this->data->begin();) {
--iter;
retval = enif_make_list_cell(env, enif_make_double(env, *iter), retval);
}
}
return retval;
}
static ERL_NIF_TERM lookat(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int arity;
const ERL_NIF_TERM *eye,*center,*up;
ERL_NIF_TERM d[16];
if(!enif_get_tuple(env,argv[0],&arity,&eye)) {
return enif_make_badarg(env);
}
if(arity!=3) {
return enif_make_badarg(env);
}
if(!enif_get_tuple(env,argv[1],&arity,¢er)) {
return enif_make_badarg(env);
}
if(arity!=3) {
return enif_make_badarg(env);
}
if(!enif_get_tuple(env,argv[2],&arity,&up)) {
return enif_make_badarg(env);
}
if(arity != 3) {
return enif_make_badarg(env);
}
glm::dvec3 veye;
if(!(enif_get_double(env,eye[0],&veye.x) &&
enif_get_double(env,eye[1],&veye.y) &&
enif_get_double(env,eye[2],&veye.z))) {
return enif_make_badarg(env);
}
glm::dvec3 vcenter;
if(!(enif_get_double(env,center[0],&vcenter.x) &&
enif_get_double(env,center[1],&vcenter.y) &&
enif_get_double(env,center[2],&vcenter.z))) {
return enif_make_badarg(env);
}
glm::dvec3 vup;
if(!(enif_get_double(env,up[0],&vup.x) &&
enif_get_double(env,up[1],&vup.y) &&
enif_get_double(env,up[2],&vup.z))) {
return enif_make_badarg(env);
}
glm::dmat4 m = glm::lookAt(veye,vcenter,vup);
const double *pSource = (const double*)glm::value_ptr(m);
for(int i =0; i<16;++i)
d[i] = enif_make_double(env,pSource[i]);
return enif_make_tuple_from_array(env,d,16);
}
ERL_NIF_TERM meter_stats(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
meter_handle* handle;
if (enif_get_resource(env,argv[0],meter_RESOURCE,(void**)&handle))
{
pthread_mutex_lock(&(handle->m));
ERL_NIF_TERM result =
enif_make_list4(env,
enif_make_tuple2(env,ATOM_COUNT,
enif_make_ulong(env, handle->p->count())),
enif_make_tuple2(env,ATOM_ONE,
enif_make_double(env,handle->p->one())),
enif_make_tuple2(env,ATOM_FIVE,enif_make_double(env, handle->p->five())),
enif_make_tuple2(env,ATOM_FIFTEEN,enif_make_double(env, handle->p->fifteen())));
pthread_mutex_unlock(&(handle->m));
return result;
}
else
return enif_make_badarg(env);
}
static ERL_NIF_TERM pos(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
/* pos(Matrix, Row, Column) -> float() */
mx_t mx;
unsigned i, j;
if (!enif_get_resource(env, argv[0], resource_type, &mx.vp) ||
!enif_get_uint(env, argv[1], &i) || (--i >= mx.p->nrows) ||
!enif_get_uint(env, argv[2], &j) || (--j >= mx.p->ncols)) {
return enif_make_badarg(env);
}
return enif_make_double(env, POS(mx.p, i,j));
}
// convert a python object to an erlang term, return the atom 'unknown' if
// the type can't be converted
static ERL_NIF_TERM pynerl_obj_to_term(ErlNifEnv* env, PyObject* obj) {
ERL_NIF_TERM term;
if (obj == Py_False) {
term = enif_make_atom(env, "false");
}
else if (obj == Py_True) {
term = enif_make_atom(env, "true");
}
else if (PyLong_Check(obj)) {
// TODO: make ints when the size allows to.
term = enif_make_long(env, PyLong_AsLong(obj));
}
else if (PyFloat_Check(obj)) {
term = enif_make_double(env, PyFloat_AsDouble(obj));
}
else if (PyTuple_Check(obj)) {
Py_ssize_t i, arity = PyTuple_Size(obj);
ERL_NIF_TERM *terms = (ERL_NIF_TERM*) malloc(sizeof(ERL_NIF_TERM) * (int)arity);
for (i = 0; i < arity; i++) {
terms[(int)i] = pynerl_obj_to_term(env, PyTuple_GetItem(obj, i));
}
term = enif_make_tuple_from_array(env, terms, (unsigned int)arity);
}
else if (PyBytes_Check(obj)) {
// XXX: the encoding must be latin1
term = enif_make_string(env, PyBytes_AsString(obj), ERL_NIF_LATIN1);
}
else if (PyUnicode_Check(obj)) {
// XXX: the encoding must be latin1
term = enif_make_string(env, PyBytes_AsString(PyUnicode_AsLatin1String(obj)), ERL_NIF_LATIN1);
}
else if (PyList_Check(obj)) {
Py_ssize_t i, arity = PyList_Size(obj);
ERL_NIF_TERM *terms = (ERL_NIF_TERM*) malloc(sizeof(ERL_NIF_TERM) * (int)arity);
for (i = 0; i < arity; i++) {
terms[(int)i] = pynerl_obj_to_term(env, PyList_GetItem(obj, i));
}
term = enif_make_list_from_array(env, terms, (unsigned int)arity);
}
else if (obj == Py_None) {
term = enif_make_atom(env, "none");
}
else {
term = enif_make_atom(env, "unknown");
}
return term;
}
BEGIN_C
static ERL_NIF_TERM mat4(ErlNifEnv *env, int args, const ERL_NIF_TERM argv[])
{
glm::mat4 d = glm::mat4(1.0f);
ERL_NIF_TERM o[16];
const float *pSource = (const float *)glm::value_ptr(d);
for(int i =0; i<16; ++i)
o[i] = enif_make_double(env,(double)pSource[i]);
return enif_make_tuple_from_array(env,o,16);
}
/**
* Erlang Wrapper for geonum_decode_bbox
*/
ERL_NIF_TERM
erl_geonum_decode_bbox(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
double tl[2], br[2];
long long geonum;
if(!enif_get_int64(env, argv[0], &geonum)) {
return enif_make_badarg(env);
}
geonum_decode_bbox(geonum, tl, br);
ERL_NIF_TERM top_left = enif_make_tuple2(env,
enif_make_double(env, tl[0]),
enif_make_double(env, tl[1]));
ERL_NIF_TERM bottom_right = enif_make_tuple2(env,
enif_make_double(env, br[0]),
enif_make_double(env, br[1]));
ERL_NIF_TERM bbox = enif_make_tuple2(env, top_left, bottom_right);
return make_ok(env, bbox);
}
static ERL_NIF_TERM cost_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
double x,y,ret;
if (!enif_get_double(env, argv[0], &x)) {
return enif_make_badarg(env);
}
if (!enif_get_double(env, argv[1], &y)) {
return enif_make_badarg(env);
}
ret = cost(x,y);
return enif_make_double(env, ret);
}
static ERL_NIF_TERM
float_deref(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
int err;
ptr_t ptr;
err = nifty_get_ptr(env, argv[0], &ptr);
if (!err) {
goto error;
}
return enif_make_double(env, ((double)(*((float*)ptr))));
error:
return enif_make_badarg(env);
}
ERL_NIF_TERM PCudaFloatBuffer::intersect(ErlNifEnv *env, PCudaBuffer *otherBuffer) {
ERL_NIF_TERM retval = enif_make_list(env, 0);
std::vector<double> intersection;
if (otherBuffer->type() == BUF_TYPE_FLOAT) {
PCudaFloatBuffer *other = (PCudaFloatBuffer *) otherBuffer;
pcuda_float_intersection(this->data, other->data, &intersection);
if (intersection.size() > 0) {
for (std::vector<double>::iterator iter = intersection.end(); iter != intersection.begin();) {
--iter;
retval = enif_make_list_cell(env, enif_make_double(env, *iter), retval);
}
}
}
return retval;
}
static ERL_NIF_TERM
sum(ErlNifEnv *env, int32_t argc, const ERL_NIF_TERM *argv) {
ErlNifBinary matrix;
float sum;
float *matrix_data;
(void)(argc);
if (!enif_inspect_binary(env, argv[0], &matrix)) return enif_make_badarg(env);
matrix_data = (float *) matrix.data;
sum = matrix_sum(matrix_data);
return enif_make_double(env, sum);
}
static ERL_NIF_TERM rotate(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
double angle;
int arity;
const ERL_NIF_TERM *t,*v;
double dm[16];
ERL_NIF_TERM d[16];
if(!enif_get_tuple(env,argv[0],&arity,&t)) {
return enif_make_badarg(env);
}
if(arity!=16) {
return enif_make_badarg(env);
}
for(int i=0; i<16; ++i) {
enif_get_double(env,t[i],&dm[i]);
}
glm::dmat4 matrix = glm::make_mat4(dm);
if(!enif_get_double(env,argv[1],&angle)) {
return enif_make_badarg(env);
}
if(!enif_get_tuple(env,argv[2],&arity,&v)) {
return enif_make_badarg(env);
}
if(arity != 3) {
return enif_make_badarg(env);
}
glm::dvec3 axis;
if(!(enif_get_double(env,v[0],&axis.x) && enif_get_double(env,v[1],&axis.y) && enif_get_double(env,v[2],&axis.z))) {
return enif_make_badarg(env);
}
glm::dmat4 rotation = glm::rotate(matrix,angle,axis);
const double *pSource = (const double*)glm::value_ptr(rotation);
for(int i =0; i<16; ++i) {
d[i] = enif_make_double(env,pSource[i]);
}
return enif_make_tuple_from_array(env,d,16);
}
static ERL_NIF_TERM cost4_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
double x1,x2,x3,x4,ret;
if (!enif_get_double(env, argv[0], &x1)) {
return enif_make_badarg(env);
}
if (!enif_get_double(env, argv[1], &x2)) {
return enif_make_badarg(env);
}
if (!enif_get_double(env, argv[2], &x3)) {
return enif_make_badarg(env);
}
if (!enif_get_double(env, argv[2], &x4)) {
return enif_make_badarg(env);
}
ret = cost4(x1,x2,x3,x4);
return enif_make_double(env, ret);
}
/*
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
{ok, Layer} = lgeo_ogr:ds_get_layer(DataSource, 0),
{ok, Feature} = lgeo_ogr:l_get_feature(Layer, 0),
{ok, Fields} = lgeo_ogr:f_get_fields(Feature).
{1,"first"}
*/
static ERL_NIF_TERM
f_get_fields(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
EnvFeature_t **feature;
ERL_NIF_TERM eterm;
if (argc != 1) {
return enif_make_badarg(env);
}
if(!enif_get_resource(env, argv[0], OGR_F_RESOURCE, (void**)&feature)) {
return enif_make_badarg(env);
}
OGRFeatureDefnH feature_defn = OGR_F_GetDefnRef((**feature).obj);
int count = OGR_FD_GetFieldCount(feature_defn);
ERL_NIF_TERM *arr = (ERL_NIF_TERM *) malloc(sizeof(ERL_NIF_TERM)*count);
int index;
for(index=0; index<count; index++)
{
OGRFieldDefnH field_defn = OGR_FD_GetFieldDefn(feature_defn, index);
if(OGR_Fld_GetType(field_defn) == OFTInteger) {
arr[index] = enif_make_int(env,
OGR_F_GetFieldAsInteger((**feature).obj, index));
} else if(OGR_Fld_GetType(field_defn) == OFTReal) {
arr[index] = enif_make_double(env,
OGR_F_GetFieldAsDouble((**feature).obj, index));
} else if(OGR_Fld_GetType(field_defn) == OFTString) {
arr[index] = enif_make_string(env,
OGR_F_GetFieldAsString((**feature).obj, index),
ERL_NIF_LATIN1);
} else {
arr[index] = enif_make_string(env,
OGR_F_GetFieldAsString((**feature).obj, index),
ERL_NIF_LATIN1);
}
}
eterm = enif_make_tuple_from_array(env, arr, index);
free(arr);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
