//pteracuda_nifs:gemv(Ctx, _m, _n, _alpha, A, X, _betha, Y),
ERL_NIF_TERM pteracuda_nifs_gemv(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaContextRef *ctxRef;
PCudaBufferRef *ref_A, *ref_X, *ref_Y;
unsigned long transpose;
unsigned long m, n;
double alpha, beta;
if (argc != 9 ||
!enif_get_resource(env, argv[0], pteracuda_context_resource, (void **) &ctxRef) ||
!enif_get_ulong(env, argv[1], &transpose)||
!enif_get_ulong(env, argv[2], &m)||
!enif_get_ulong(env, argv[3], &n)||
!enif_get_double(env, argv[4], &alpha)||
!enif_get_resource(env, argv[5], pteracuda_buffer_resource, (void **) &ref_A) ||
!enif_get_resource(env, argv[6], pteracuda_buffer_resource, (void **) &ref_X)||
!enif_get_double(env, argv[7], &beta)||
!enif_get_resource(env, argv[8], pteracuda_buffer_resource, (void **) &ref_Y)) {
return enif_make_badarg(env);
}
if(((PCudaMatrixFloatBuffer*)ref_A->buffer)->rows() != m || ((PCudaMatrixFloatBuffer*)ref_A->buffer)->cols() != n){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix A dimensions do not match m,n parameters"));
}
cuCtxSetCurrent(ctxRef->ctx);
pcuda_gemv(transpose, m, n, alpha, ((PCudaMatrixFloatBuffer *)ref_A->buffer)->get_data(), ((PCudaFloatBuffer *)ref_X->buffer)->get_data(), beta, ((PCudaFloatBuffer *)ref_Y->buffer)->get_data());
return ATOM_OK;
}
/**
* Erlang Wrapper for geonum_encode
*/
ERL_NIF_TERM
erl_geonum_encode(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
double lat;
double lon;
int precision;
long long bin_geonum[1];
if(!enif_get_double(env, argv[0], &lat)) {
return enif_make_badarg(env);
}
if(!enif_get_double(env, argv[1], &lon)) {
return enif_make_badarg(env);
}
if(!enif_get_int(env, argv[2], &precision)) {
return enif_make_badarg(env);
}
if(precision >= GEONUM_MAX || precision < 1) {
return make_error(env, "precision_range");
}
geonum_encode(lat, lon, precision, bin_geonum);
return make_ok(env, enif_make_int64(env, bin_geonum[0]));
}
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 btRigidBody_setDamping(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
double lin_damping,and_damping;
enif_get_double(env, argv[1], &lin_damping);
enif_get_double(env, argv[2], &and_damping);
((btRigidBody*)unwrap_pointer(env,btRigidBody_resource,argv[0]))->setDamping(lin_damping,and_damping);
return enif_make_atom(env, "ok");
}
/* Currently support for 2 dimensions only */
int
set_GEOSCoordSeq_from_eterm_list(GEOSCoordSequence *seq, int pos,
ErlNifEnv *env, const ERL_NIF_TERM *coords) {
double dbl_coord;
int int_coord;
ERL_NIF_TERM head, tail;
if (enif_get_list_cell(env, *coords, &head, &tail)) {
if (enif_get_int(env, head, &int_coord)) {
dbl_coord = int_coord;
}
else if (!enif_get_double(env, head, &dbl_coord)) {
return 0;
}
GEOSCoordSeq_setX(seq, pos, dbl_coord);
enif_get_list_cell(env, tail, &head, &tail);
if (enif_get_int(env, head, &int_coord)) {
dbl_coord = int_coord;
}
else if (!enif_get_double(env, head, &dbl_coord)) {
return 0;
}
GEOSCoordSeq_setY(seq, pos, dbl_coord);
return 1;
}
return 0;
}
static btVector3 get_vector(ErlNifEnv *env, const ERL_NIF_TERM arg) {
double x,y,z;
const ERL_NIF_TERM *tuple;
int arity;
enif_get_tuple(env, arg, &arity, &tuple);
enif_get_double(env, tuple[0], &x);
enif_get_double(env, tuple[1], &y);
enif_get_double(env, tuple[2], &z);
return btVector3(x,y,z);
}
static btQuaternion get_quaternion(ErlNifEnv *env, const ERL_NIF_TERM arg) {
double x,y,z,w;
const ERL_NIF_TERM *tuple;
int arity;
enif_get_tuple(env, arg, &arity, &tuple);
enif_get_double(env, tuple[0], &x);
enif_get_double(env, tuple[1], &y);
enif_get_double(env, tuple[2], &z);
enif_get_double(env, tuple[3], &w);
return btQuaternion(x,y,z,w);
}
///////////////////Matrix operations
// C(m,n) = A(m,k) * B(k,n)
//gemm(_Ctx, _transpose_op_A, _transpose_op_B, _m, _n, _k, _alpha, _A, _B, _beta, _C )
ERL_NIF_TERM pteracuda_nifs_gemm(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaContextRef *ctxRef;
PCudaBufferRef *ref_A, *ref_B, *ref_C;
unsigned long transpose_a, transpose_b;
unsigned long m, n, k;
double alpha, beta;
if (argc != 11 || !enif_get_resource(env, argv[0], pteracuda_context_resource, (void **) &ctxRef) ||
!enif_get_ulong(env, argv[1], &transpose_a)||
!enif_get_ulong(env, argv[2], &transpose_b)||
!enif_get_ulong(env, argv[3], &m)||
!enif_get_ulong(env, argv[4], &n)||
!enif_get_ulong(env, argv[5], &k)||
!enif_get_double(env, argv[6], &alpha)||
!enif_get_resource(env, argv[7], pteracuda_buffer_resource, (void **) &ref_A) ||
!enif_get_resource(env, argv[8], pteracuda_buffer_resource, (void **) &ref_B)||
!enif_get_double(env, argv[9], &beta)||
!enif_get_resource(env, argv[10], pteracuda_buffer_resource, (void **) &ref_C)
) {
return enif_make_badarg(env);
}
if(transpose_a == CUBLAS_OP_N){
if(((PCudaMatrixFloatBuffer*)ref_A->buffer)->rows() != m || ((PCudaMatrixFloatBuffer*)ref_A->buffer)->cols() != k){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix A dimensions do not match m,k parameters"));
}
}else{
if(((PCudaMatrixFloatBuffer*)ref_A->buffer)->rows() != k || ((PCudaMatrixFloatBuffer*)ref_A->buffer)->cols() != n){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix A dimensions do not match m,k parameters"));
}
}
if(transpose_b == CUBLAS_OP_N){
if(((PCudaMatrixFloatBuffer*)ref_B->buffer)->rows() != k || ((PCudaMatrixFloatBuffer*)ref_B->buffer)->cols() != n){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix B dimensions do not match k,n parameters"));
}
}else{
if(((PCudaMatrixFloatBuffer*)ref_B->buffer)->rows() != n || ((PCudaMatrixFloatBuffer*)ref_B->buffer)->cols() != k){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix B dimensions do not match k,n parameters"));
}
}
if(((PCudaMatrixFloatBuffer*)ref_C->buffer)->rows() != m || ((PCudaMatrixFloatBuffer*)ref_C->buffer)->cols() != n){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Matrix C dimensions do not match m,n parameters"));
}
cuCtxSetCurrent(ctxRef->ctx);
//pcuda_mmul(((PCudaMatrixFloatBuffer*)ref_A->buffer)->get_data(), ((PCudaMatrixFloatBuffer*)ref_B->buffer)->get_data(), ((PCudaMatrixFloatBuffer*)ref_C->buffer)->get_data(), m, k, n);
pcuda_gemm(transpose_a, transpose_b, m, n, k, alpha, ((PCudaMatrixFloatBuffer*)ref_A->buffer)->get_data(), ((PCudaMatrixFloatBuffer*)ref_B->buffer)->get_data(), beta, ((PCudaMatrixFloatBuffer*)ref_C->buffer)->get_data());
return ATOM_OK;
}
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 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 date_get_field(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
UErrorCode status = U_ZERO_ERROR;
UCalendar* cal;
cloner* ptr;
double date;
ERL_NIF_TERM res;
if(!((argc == 3)
&& enif_get_resource(env, argv[0], calendar_type, (void**) &ptr)
&& enif_get_double(env, argv[1], &date))) {
return enif_make_badarg(env);
}
cal = (UCalendar*) cloner_get(ptr);
CHECK_RES(env, cal);
ucal_setMillis(cal, (UDate) date, &status);
CHECK(env, status);
res = do_date_get_field(env, cal, argv[2], status);
CHECK(env, status);
return res;
}
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 pteracuda_ml_gd_learn(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaContextRef *ctxRef;
PCudaBufferRef *ref_Theta, *ref_X, *ref_Y;
unsigned long num_features;
unsigned long num_samples;
unsigned long iterations;
double learning_rate;
if (argc != 8 || !enif_get_resource(env, argv[0], pteracuda_context_resource, (void **) &ctxRef) ||
!enif_get_resource(env, argv[1], pteracuda_buffer_resource, (void **) &ref_Theta) ||
!enif_get_resource(env, argv[2], pteracuda_buffer_resource, (void **) &ref_X) ||
!enif_get_resource(env, argv[3], pteracuda_buffer_resource, (void **) &ref_Y) ||
!enif_get_ulong(env, argv[4], &num_features) ||
!enif_get_ulong(env, argv[5], &num_samples) ||
!enif_get_double(env, argv[6], &learning_rate) ||
!enif_get_ulong(env, argv[7], &iterations)
) {
return enif_make_badarg(env);
}
cuCtxSetCurrent(ctxRef->ctx);
pcuda_gd_learn(((PCudaFloatBuffer*)ref_Theta->buffer)->get_data(), ((PCudaFloatBuffer*)ref_X->buffer)->get_data(), ((PCudaFloatBuffer*)ref_Y->buffer)->get_data(), num_features, num_samples, (float)learning_rate, iterations);
return ATOM_OK;
}
ERL_NIF_TERM pteracuda_nifs_saxpy(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaContextRef *ctxRef;
PCudaBufferRef *ref_X, *ref_Y;
double a;
if (argc != 4 ||
!enif_get_resource(env, argv[0], pteracuda_context_resource, (void **) &ctxRef) ||
!enif_get_double(env, argv[1], &a)||
!enif_get_resource(env, argv[2], pteracuda_buffer_resource, (void **) &ref_X)||
!enif_get_resource(env, argv[3], pteracuda_buffer_resource, (void **) &ref_Y)) {
return enif_make_badarg(env);
}
if(((PCudaFloatBuffer *)ref_X->buffer)->get_data()->size() != ((PCudaFloatBuffer *)ref_Y->buffer)->get_data()->size()){
return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Size X does not match size Y."));
}
cuCtxSetCurrent(ctxRef->ctx);
pcuda_saxpy(a, ((PCudaFloatBuffer *)ref_X->buffer)->get_data(), ((PCudaFloatBuffer *)ref_Y->buffer)->get_data());
return ATOM_OK;
}
static ERL_NIF_TERM btCollisionShape_calculateLocalInertia(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
btVector3 ret;
double mass;
enif_get_double(env, argv[1], &mass);
((btCollisionShape*)unwrap_pointer(env,btCollisionShape_resource,argv[0]))->calculateLocalInertia((btScalar)mass,ret);
return vector_to_tuple(env,ret);
}
static ERL_NIF_TERM
multiply_with_scalar(ErlNifEnv *env, int argc, const ERL_NIF_TERM *argv) {
ErlNifBinary matrix;
ERL_NIF_TERM result;
double large_scalar;
float scalar;
float *matrix_data, *result_data;
int32_t data_size;
size_t result_size;
(void)(argc);
if (!enif_inspect_binary(env, argv[0], &matrix)) return enif_make_badarg(env);
if (enif_get_double(env, argv[1], &large_scalar) == 0) {
long long_element;
enif_get_int64(env, argv[1], &long_element);
large_scalar = (double) long_element;
}
scalar = (float) large_scalar;
matrix_data = (float *) matrix.data;
data_size = (int32_t) (matrix_data[0] * matrix_data[1] + 2);
result_size = sizeof(float) * data_size;
result_data = (float *) enif_make_new_binary(env, result_size, &result);
matrix_multiply_with_scalar(matrix_data, scalar, result_data);
return result;
}
static ERL_NIF_TERM
float_ref(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
int err;
double helper;
float *value;
value = enif_alloc(sizeof(float));
if (!value) {
goto error;
}
err = enif_get_double(env, argv[0], &helper);
if (!err) {
enif_free(value);
goto error;
}
*value = (float)helper;
return enif_make_tuple2(env,
nifty_make_ptr(env, (ptr_t)value),
enif_make_string(env, "nifty.float *", ERL_NIF_LATIN1));
error:
return enif_make_badarg(env);
}
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);
}
ERL_NIF_TERM date_diff_field(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
UErrorCode status = U_ZERO_ERROR;
UCalendar* cal;
cloner* ptr;
double startMs, targetMs;
char value[ATOM_LEN];
int parsed_value, amount;
UCalendarDateFields field;
if(!((argc == 4)
&& enif_get_resource(env, argv[0], calendar_type, (void**) &ptr)
&& enif_get_double(env, argv[1], &startMs)
&& enif_get_double(env, argv[2], &targetMs)
&& enif_get_atom(env, argv[3], (char*) value, ATOM_LEN,
ERL_NIF_LATIN1))) {
return enif_make_badarg(env);
}
cal = (UCalendar*) cloner_get(ptr);
CHECK_RES(env, cal);
ucal_setMillis(cal, (UDate) startMs, &status);
CHECK(env, status);
parsed_value = parseCalendarDateField(value);
if (parsed_value == -1) {
status = U_ILLEGAL_ARGUMENT_ERROR;
CHECK(env, status);
}
field = (UCalendarDateFields) parsed_value;
amount = (int) dateFieldDifference(cal,
targetMs,
field,
status);
CHECK(env, status);
return enif_make_int(env, amount);
}
static ERL_NIF_TERM mutate_solution(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
// struct timespec start, end;
// long diff;
// clock_gettime(CLOCK_MONOTONIC, &start);
ERL_NIF_TERM term;
ErlNifResourceType* sol_type;
Solution *sol, *mut_sol;
// unsigned int i;
double range, rate;
CHECK(env, argc == 3)
sol_type = (ErlNifResourceType*) enif_priv_data(env);
CHECK(env, sol_type)
CHECK(env, enif_get_resource(env, argv[0], sol_type, (void**) &sol))
CHECK(env, enif_get_double(env, argv[1], &range))
CHECK(env, enif_get_double(env, argv[2], &rate))
mut_sol = (Solution*) enif_alloc_resource(sol_type, sizeof(Solution));
CHECK(env, mut_sol)
term = enif_make_resource(env, mut_sol);
CHECK(env,term)
enif_release_resource(mut_sol);
mut_sol->len = sol->len;
mut_sol->genotype = (double*) malloc(sizeof(double)*sol->len);
mutate(sol, mut_sol, range, rate);
#ifdef DEBUG
print_solution(sol, "Genotype");
print_solution(mut_sol, "MutatedGenotype");
#endif
// clock_gettime(CLOCK_MONOTONIC, &end);
// diff = CLOCKS_PER_SEC * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
// printf("mut=%llu\n", (long long unsigned int) diff);
return term;
}
ERL_NIF_TERM date_clear(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
UErrorCode status = U_ZERO_ERROR;
UCalendar* cal;
cloner* ptr;
double date;
UCalendarDateFields field;
ERL_NIF_TERM head, tail;
unsigned int count, i = 0;
char value[ATOM_LEN];
int parsed_value;
if(!((argc == 3)
&& enif_get_resource(env, argv[0], calendar_type, (void**) &ptr)
&& enif_get_double(env, argv[1], &date)
&& enif_get_list_length(env, argv[2], &count))) {
return enif_make_badarg(env);
}
cal = (UCalendar*) cloner_get(ptr);
CHECK_RES(env, cal);
ucal_setMillis(cal, (UDate) date, &status);
CHECK(env, status);
tail = argv[2];
while (enif_get_list_cell(env, tail, &head, &tail)) {
/* Set an attribute start */
if (!enif_get_atom(env, head, (char*) value,
ATOM_LEN, ERL_NIF_LATIN1))
goto bad_elem;
parsed_value = parseCalendarDateField(value);
if ((parsed_value == -1))
goto bad_elem;
field = (UCalendarDateFields) parsed_value;
ucal_clearField(cal, field);
if (U_FAILURE(status))
goto bad_elem;
/* Set an attribute end */
}
return calendar_to_double(env, (const UCalendar*) cal);
bad_elem:
return list_element_error(env, argv[2], i);
}
bool PCudaFloatBuffer::contains(ErlNifEnv *env, ERL_NIF_TERM rawTarget) {
double target;
if (enif_get_double(env, rawTarget, &target)) {
return pcuda_float_binary_search(this->data, target);
}
else {
return false;
}
}
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);
}
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 inline int
match_double(ErlNifEnv* env, ERL_NIF_TERM term, State *st){
double dp;
int n;
if(!enif_get_double(env, term, &dp))
return 0;
b_reserve(24, st);
n = sprintf((char *)st->cur, "%.15g", dp);
b_seek(n, st);
return 1;
}
static ERL_NIF_TERM new_btRigidBodyConstructionInfo(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
double mass;
btVector3 inertia = get_vector(env,argv[3]);
enif_get_double(env, argv[0], &mass);
return wrap_pointer(env,btRigidBodyConstructionInfo_resource, new btRigidBody::btRigidBodyConstructionInfo(
mass,
(btMotionState*)unwrap_pointer(env,btMotionState_resource,argv[1]),
(btCollisionShape*)unwrap_pointer(env,btCollisionShape_resource,argv[2]),
inertia
));
}
static ERL_NIF_TERM translate(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
double x,y,z;
ERL_NIF_TERM d[16];
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);
}
if(!enif_get_double(env,argv[2],&z)) {
return enif_make_badarg(env);
}
glm::mat4 trans = glm::translate(glm::mat4(1.0f), glm::vec3((float)x,(float)y,(float)z));
const float *pSource = (const float*)glm::value_ptr(trans);
for(int i =0; i<16;++i)
d[i] = enif_make_double(env,(double)pSource[i]);
return enif_make_tuple_from_array(env,d,16);
}
bool PCudaFloatBuffer::insert_at(unsigned long position, ErlNifEnv *env, ERL_NIF_TERM rawValue) {
double value;
if (enif_get_double(env, rawValue, &value)) {
std::vector<double>::iterator iter = this->data->begin();
for (unsigned long i = 0; i < position; i++) {
iter++;
}
this->data->insert(iter, 1, value);
return true;
}
return false;
}
static int
bind_cell(ErlNifEnv *env, const ERL_NIF_TERM cell, sqlite3_stmt *stmt, unsigned int i)
{
int the_int;
ErlNifSInt64 the_long_int;
double the_double;
char the_atom[MAX_ATOM_LENGTH+1];
ErlNifBinary the_blob;
int arity;
const ERL_NIF_TERM* tuple;
if(enif_get_int(env, cell, &the_int))
return sqlite3_bind_int(stmt, i, the_int);
if(enif_get_int64(env, cell, &the_long_int))
return sqlite3_bind_int64(stmt, i, the_long_int);
if(enif_get_double(env, cell, &the_double))
return sqlite3_bind_double(stmt, i, the_double);
if(enif_get_atom(env, cell, the_atom, sizeof(the_atom), ERL_NIF_LATIN1)) {
if(strcmp("undefined", the_atom) == 0) {
return sqlite3_bind_null(stmt, i);
}
return sqlite3_bind_text(stmt, i, the_atom, strlen(the_atom), SQLITE_TRANSIENT);
}
/* Bind as text assume it is utf-8 encoded text */
if(enif_inspect_iolist_as_binary(env, cell, &the_blob))
return sqlite3_bind_text(stmt, i, (char *) the_blob.data, the_blob.size, SQLITE_TRANSIENT);
/* Check for blob tuple */
if(enif_get_tuple(env, cell, &arity, &tuple)) {
if(arity != 2)
return -1;
/* length 2! */
if(enif_get_atom(env, tuple[0], the_atom, sizeof(the_atom), ERL_NIF_LATIN1)) {
/* its a blob... */
if(0 == strncmp("blob", the_atom, strlen("blob"))) {
/* with a iolist as argument */
if(enif_inspect_iolist_as_binary(env, tuple[1], &the_blob)) {
/* kaboom... get the blob */
return sqlite3_bind_blob(stmt, i, the_blob.data, the_blob.size, SQLITE_TRANSIENT);
}
}
}
}
return -1;
}
// convert an erlang term to a python object
// return None if the type can't be converted
static PyObject* pynerl_term_to_obj(ErlNifEnv* env, ERL_NIF_TERM term) {
int vint;
Py_ssize_t arity, i;
long int vlong;
double vdouble;
char buff[BUFF_SIZE];
PyObject* obj;
ERL_NIF_TERM list, head, tail;
const ERL_NIF_TERM *terms;
// TODO: add more types
if (enif_get_long(env, term, &vlong)) {
obj = PyLong_FromLong(vlong);
}
else if (enif_get_double(env, term, &vdouble)) {
obj = PyFloat_FromDouble(vlong);
}
else if (enif_is_empty_list(env, term)) {
obj = PyList_New(0);
}
else if (enif_get_tuple(env, term, &vint, &terms)) {
arity = vint;
obj = PyTuple_New(arity);
for (i = 0; i < arity; i++) {
PyTuple_SetItem(obj, i, pynerl_term_to_obj(env, terms[(int)i]));
}
}
else if (enif_is_identical(term, enif_make_atom(env, "true"))) {
obj = Py_True;
}
else if (enif_is_identical(term, enif_make_atom(env, "false"))) {
obj = Py_False;
}
else if (enif_get_string(env, term, buff, BUFF_SIZE, ERL_NIF_LATIN1)) {
obj = PyUnicode_FromString(buff);
}
else if (enif_get_list_cell(env, term, &head, &tail)) {
obj = PyList_New(0);
list = term;
while (enif_get_list_cell(env, list, &head, &tail)) {
PyList_Append(obj, pynerl_term_to_obj(env, head));
list = tail;
}
}
else {
obj = Py_None;
}
return obj;
}
