static ERL_NIF_TERM
divide(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM r;
ErlNifSInt64* vs;
ErlNifSInt64 m;
ErlNifSInt64* target;
int count;
if (argc != 2)
return enif_make_badarg(env);
GET_BIN(0, bin, count, vs);
if (!enif_get_int64(env, argv[1], &m))
return enif_make_badarg(env);
if (!m)
return enif_make_badarg(env);
if (! (target = (ErlNifSInt64*) enif_make_new_binary(env, bin.size, &r)))
return enif_make_badarg(env); // TODO return propper error
for (int i = 0; i < count; i++) {
if (IS_SET(vs[i])) {
target[i] = TO_DDB(FROM_DDB(vs[i]) / m);
} else {
target[i] = 0;
}
}
return r;
}
static ERL_NIF_TERM
derivate_r(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM r;
ErlNifSInt64* target;
ErlNifSInt64* vs;
int count;
if (argc != 1)
return enif_make_badarg(env);
GET_BIN(0, bin, count, vs);
if (count < 1) // can't be empty
return enif_make_badarg(env);
if (! (target = (ErlNifSInt64*) enif_make_new_binary(env, bin.size - sizeof(ErlNifSInt64), &r)))
return enif_make_badarg(env); // TODO return propper error
for (int i = 1; i < count; i++) {
target[i - 1] = vs[i] - vs[i-1];
}
return r;
}
static ERL_NIF_TERM
mul_r(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM r;
ErlNifSInt64* vs;
ErlNifSInt64 m;
ErlNifSInt64* target;
int count;
if (argc != 2)
return enif_make_badarg(env);
GET_BIN(0, bin, count, vs);
if (!enif_get_int64(env, argv[1], &m))
return enif_make_badarg(env);
if (! (target = (ErlNifSInt64*) enif_make_new_binary(env, bin.size, &r)))
return enif_make_badarg(env); // TODO return propper error
for (int i = 0; i < count; i++) {
target[i] = vs[i] * m;
}
return r;
}
/***************************************************
* Function: DensityGrid::GetDensity *
* Description: Get_Density from density grid *
**************************************************/
float DensityGrid::GetDensity(float Nx, float Ny, float Nz,bool fineDensity)
{
deque<Node>::iterator BI;
int x_grid, y_grid, z_grid;
float x_dist, y_dist, z_dist, distance, density=0;
int boundary=10; // boundary around plane
/* Where to look */
x_grid = (int)((Nx+HALF_VIEW+.5)*VIEW_TO_GRID);
y_grid = (int)((Ny+HALF_VIEW+.5)*VIEW_TO_GRID);
z_grid = (int)((Nz+HALF_VIEW+.5)*VIEW_TO_GRID);
// Check for edges of density grid (10000 is arbitrary high density)
if (x_grid > GRID_SIZE-boundary || x_grid < boundary) return 10000;
if (y_grid > GRID_SIZE-boundary || y_grid < boundary) return 10000;
if (z_grid > GRID_SIZE-boundary || z_grid < boundary) return 10000;
// Fine density?
if (fineDensity) {
// Go through nearest bins
for (int k=z_grid-1; k<=z_grid+1; k++)
for(int i=y_grid-1; i<=y_grid+1; i++)
for(int j=x_grid-1; j<=x_grid+1; j++) {
// Look through bin and add fine repulsions
for(BI = GET_BIN(k,i,j).begin(); BI < GET_BIN(k,i,j).end(); ++BI) {
x_dist = Nx-(BI->x);
y_dist = Ny-(BI->y);
z_dist = Nz-(BI->z);
distance = x_dist*x_dist+y_dist*y_dist+z_dist*z_dist;
density += 1e-4/(distance + 1e-50);
}
}
// Course density
} else {
// Add rough estimate
density = Density[z_grid][y_grid][x_grid];
density *= density;
}
return density;
}
int get_bin2(void **buf, int *len, void **value, size_t *n)
{
GET_BIN_ARG_CHECK;
uint16_t blen = 0;
if (get_uint16(buf, len, &blen) < 0)
return -2;
GET_BIN(blen);
}
/***************************************************
* Function: DensityGrid::fineSubtract *
* Description: Subtract a node from bins *
**************************************************/
void DensityGrid::fineSubtract(Node &N)
{
int x_grid, y_grid, z_grid;
/* Where to subtract */
x_grid = (int)((N.sub_x+HALF_VIEW+.5)*VIEW_TO_GRID);
y_grid = (int)((N.sub_y+HALF_VIEW+.5)*VIEW_TO_GRID);
z_grid = (int)((N.sub_z+HALF_VIEW+.5)*VIEW_TO_GRID);
GET_BIN(z_grid,y_grid,x_grid).pop_front();
}
void DensityGrid::Init()
{
try
{
Density = new float[GRID_SIZE][GRID_SIZE][GRID_SIZE];
fall_off = new float[RADIUS*2+1][RADIUS*2+1][RADIUS*2+1];
Bins = new deque<Node>[GRID_SIZE*GRID_SIZE*GRID_SIZE];
}
catch (bad_alloc errora)
{
// cout << "Error: Out of memory! Program stopped." << endl;
#ifdef MUSE_MPI
MPI_Abort ( MPI_COMM_WORLD, 1 );
#else
igraph_error("DrL is out of memory", __FILE__, __LINE__,
IGRAPH_ENOMEM);
#endif
}
// Clear Grid
int i;
for (i=0; i< GRID_SIZE; i++)
for (int j=0; j< GRID_SIZE; j++)
for (int k=0; k < GRID_SIZE; k++) {
Density[i][j][k] = 0;
GET_BIN(i,j,k).erase(GET_BIN(i,j,k).begin(),GET_BIN(i,j,k).end());
}
// Compute fall off
for(i=-RADIUS; i<=RADIUS; i++)
for(int j=-RADIUS; j<=RADIUS; j++)
for (int k=-RADIUS; k<=RADIUS; k++) {
fall_off[i+RADIUS][j+RADIUS][k+RADIUS] =
(float)((RADIUS-fabs((float)i))/RADIUS) *
(float)((RADIUS-fabs((float)j))/RADIUS) *
(float)((RADIUS-fabs((float)k))/RADIUS);
}
}
/***************************************************
* Function: DensityGrid::fineAdd *
* Description: Add a node to the bins *
**************************************************/
void DensityGrid::fineAdd(Node &N)
{
int x_grid, y_grid, z_grid;
/* Where to add */
x_grid = (int)((N.x+HALF_VIEW+.5)*VIEW_TO_GRID);
y_grid = (int)((N.y+HALF_VIEW+.5)*VIEW_TO_GRID);
z_grid = (int)((N.z+HALF_VIEW+.5)*VIEW_TO_GRID);
N.sub_x = N.x;
N.sub_y = N.y;
N.sub_z = N.z;
GET_BIN(z_grid,y_grid,x_grid).push_back(N);
}
static ERL_NIF_TERM
min_r(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM r;
ErlNifSInt64* vs;
ErlNifSInt64* target;
ErlNifSInt64 chunk; // size to be compressed
ErlNifSInt64 target_i = 0; // target position
ErlNifSInt64 aggr; // target position
uint32_t pos;
uint32_t count;
uint32_t target_size;
if (argc != 2)
return enif_make_badarg(env);
GET_CHUNK(chunk);
GET_BIN(0, bin, count, vs);
target_size = ceil((double) count / chunk) * sizeof(ErlNifSInt64);
if (! (target = (ErlNifSInt64*) enif_make_new_binary(env, target_size, &r)))
return enif_make_badarg(env); // TODO return propper error
// If we don't have any input data we can return right away.
if (count == 0)
return r;
// We know we have at least one element in the list so our
// aggregator will start with this
aggr = vs[0];
pos = 1;
// We itterate over the remining i .. count-1 elements
for (uint32_t i = 1; i < count; i++, pos++) {
if (pos == chunk) {
target[target_i] = aggr;
target_i++;
aggr = vs[i];
pos = 0;
} else {
if (vs[i] < aggr) {
aggr = vs[i];
};
}
}
// Making sure the last aggregate is saved.
if (target_i < target_size)
target[target_i] = aggr;
return r;
}
static ERL_NIF_TERM
avg_r(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM r;
ErlNifSInt64* vs;
ErlNifSInt64* target;
ErlNifSInt64 chunk; // size to be compressed
ErlNifSInt64 aggr; // Aggregator
uint32_t target_i = 0; // target position
uint32_t count;
uint32_t pos = 0;
uint32_t target_size;
if (argc != 2)
return enif_make_badarg(env);
GET_CHUNK(chunk);
GET_BIN(0, bin, count, vs);
target_size = ceil((double) count / chunk) * sizeof(ErlNifSInt64);
if (! (target = (ErlNifSInt64*) enif_make_new_binary(env, target_size, &r)))
return enif_make_badarg(env); // TODO return propper error
if (count == 0)
return r;
aggr = vs[0];
pos++;
for (uint32_t i = 1; i < count; i++, pos++) {
if (pos == chunk) {
target[target_i] = aggr / chunk;
target_i++;
aggr = vs[i];
pos = 0;
} else {
aggr += vs[i];
}
}
if (count % chunk) {
aggr += vs[count - 1] * (chunk - (count % chunk));
}
target[target_i] = aggr / chunk;
return r;
}
static ERL_NIF_TERM
derivate(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM r;
ErlNifSInt64 last;
ErlNifSInt64* target;
ErlNifSInt64* vs;
int count;
int has_value;
if (argc != 1)
return enif_make_badarg(env);
GET_BIN(0, bin, count, vs);
if (count < 1) // can't be empty
return enif_make_badarg(env);
if (! (target = (ErlNifSInt64*) enif_make_new_binary(env, bin.size - sizeof(ErlNifSInt64), &r)))
return enif_make_badarg(env); // TODO return propper error
has_value = IS_SET(vs[0]);
if (has_value) {
last = FROM_DDB(vs[0]);
}
for (int i = 1; i < count; i++) {
if (IS_SET(vs[i])) {
if (has_value) {
ErlNifSInt64 this = FROM_DDB(vs[i]);
target[i - 1] = TO_DDB(this - last);
last = this;
} else {
target[i - 1] = 0;
last = FROM_DDB(vs[i]);
has_value = 1;
}
} else {
if (has_value) {
target[i - 1] = TO_DDB(0);
} else {
target[i - 1] = 0;
}
}
}
return r;
}
static ERL_NIF_TERM
empty(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM r;
ErlNifSInt64* vs;
ErlNifSInt64* target;
ErlNifSInt64 chunk; // size to be compressed
ErlNifSInt64 target_i = 0; // target position
ErlNifSInt64 pos = 0; // position in chunk
ErlNifSInt64 aggr = 0; // aggregated value for this chunk
int count;
int target_size;
if (argc != 2)
return enif_make_badarg(env);
GET_CHUNK(chunk);
GET_BIN(0, bin, count, vs);
target_size = ceil((double) count / chunk) * sizeof(ErlNifSInt64);
if (! (target = (ErlNifSInt64*) enif_make_new_binary(env, target_size, &r)))
return enif_make_badarg(env); // TODO return propper error
if (count == 0)
return r;
pos = 0;
for (int i = 0; i < count; i++, pos++) {
if (pos == chunk) {
target[target_i] = TO_DDB(aggr);
target_i++;
aggr = !IS_SET(vs[i]);
pos = 0;
} else {
aggr += !IS_SET(vs[i]);
}
}
if (count % chunk) {
aggr += (chunk - (count % chunk));
}
target[target_i] = TO_DDB(aggr);
return r;
}
static ERL_NIF_TERM
avg(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
ERL_NIF_TERM r;
ErlNifSInt64* vs;
ErlNifSInt64* target;
ErlNifSInt64 chunk; // size to be compressed
ErlNifSInt64 target_i = 0; // target position
ErlNifSInt64 pos = 0; // position in chunk
ErlNifSInt64 aggr = 0; // aggregated value for this chunk
ErlNifSInt64 last = 0;
int count;
int has_value = 0;
int has_last = 0;
int target_size;
if (argc != 2)
return enif_make_badarg(env);
GET_CHUNK(chunk);
GET_BIN(0, bin, count, vs);
target_size = ceil((double) count / chunk) * sizeof(ErlNifSInt64);
if (! (target = (ErlNifSInt64*) enif_make_new_binary(env, target_size, &r)))
return enif_make_badarg(env); // TODO return propper error
// If we don't have any input data we can return right away.
if (count == 0)
return r;
// We know we have at least one element in the list so our
// aggregator will start with this
if (IS_SET(vs[0])) {
aggr = FROM_DDB(vs[0]);
last = aggr;
has_value = 1;
has_last = 1;
};
pos = 1;
// We itterate over the remining i .. count-1 elements
for (int i = 1; i < count; i++, pos++) {
if (pos == chunk) {
if (has_value) {
target[target_i] = TO_DDB(aggr / chunk);
} else {
target[target_i] = 0;
}
target_i++;
has_value = IS_SET(vs[i]);
if (has_value) {
aggr = FROM_DDB(vs[i]);
last = aggr;
has_last = 1;
} else if (has_last) {
aggr = last;
has_value = 1;
}
pos = 0;
} else if (!has_value) {
if (IS_SET(vs[i])) {
aggr = FROM_DDB(vs[i]);
last = aggr;
has_value = 1;
has_last = 1;
};
} else {
if (IS_SET(vs[i])) {
last = FROM_DDB(vs[i]);
aggr += last;
has_last = 1;
has_value = 1;
} else if (has_last) {
aggr += last;
has_value = 1;
}
}
}
if (has_value) {
if (count % chunk) {
aggr += (last * (chunk - (count % chunk)));
}
target[target_i] = TO_DDB(aggr / chunk);
} else {
target[target_i] = 0;
}
return r;
}
static char *pkgtostr(struct sockaddr_in *client_addr, char *pkg, int len, uint64_t *hash_key)
{
int ret;
void *p = pkg;
int left = len;
static char str[UINT16_MAX * 10];
size_t use = 0;
static void *buf;
static size_t buf_len;
/* make sure buf is not NULL */
auto_realloc(&buf, &buf_len, 128);
struct column *curr = settings.columns;
while (curr)
{
switch (curr->type)
{
case COLUMN_TYPE_TINY_INT:
GET_INT(uint8, PRIu8, int8, PRIi8);
break;
case COLUMN_TYPE_SMALL_INT:
GET_INT(uint16, PRIu16, int16, PRIi16);
break;
case COLUMN_TYPE_INT:
GET_INT(uint32, PRIu32, int32, PRIi32);
break;
case COLUMN_TYPE_BIG_INT:
GET_INT(uint64, PRIu64, int64, PRIi64);
break;
case COLUMN_TYPE_FLOAT:
{
float v = 0.0;
if (curr->is_zero == false)
FAIL_LOG(get_float(&p, &left, &v));
if (curr->is_storage)
use += snprintf(str + use, sizeof(str) - use, "%.7g,", v);
}
break;
case COLUMN_TYPE_DOUBLE:
{
double v = 0.0;
if (curr->is_zero == false)
FAIL_LOG(get_double(&p, &left, &v));
if (curr->is_storage)
use += snprintf(str + use, sizeof(str) - use, "%.16g,", v);
}
break;
case COLUMN_TYPE_CHAR:
GET_STR(get_str1);
break;
case COLUMN_TYPE_VARCHAR:
GET_STR(get_str2);
break;
case COLUMN_TYPE_TINY_TEXT:
GET_STR(get_str1);
break;
case COLUMN_TYPE_TEXT:
GET_STR(get_str2);
break;
case COLUMN_TYPE_BINARY:
GET_BIN(get_bin1);
break;
case COLUMN_TYPE_VARBINARY:
GET_BIN(get_bin2);
break;
case COLUMN_TYPE_TINY_BLOB:
GET_BIN(get_bin1);
break;
case COLUMN_TYPE_BLOB:
GET_BIN(get_bin2);
break;
case COLUMN_TYPE_DATE:
GET_TIME(get_date_str);
break;
case COLUMN_TYPE_TIME:
GET_TIME(get_time_str);
break;
case COLUMN_TYPE_DATETIME:
GET_TIME(get_datetime_str);
break;
default:
log_fatal("unknow column type: %d", curr->type);
break;
}
curr = curr->next;
}
/* delete last comma */
use -= 1;
str[use] = 0;
return str;
}
