/**
* Assign vector with variable argument list of specificed element.
*/
void _vector_assign_elem_varg(vector_t* pvec_vector, size_t t_count, va_list val_elemlist)
{
iterator_t it_iter;
iterator_t it_begin;
iterator_t it_end;
bool_t b_result = false;
void* pv_varg = NULL;
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/* get value from varg */
pv_varg = _alloc_allocate(&pvec_vector->_t_allocator, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
assert(pv_varg != NULL);
_vector_get_varg_value_auxiliary(pvec_vector, val_elemlist, pv_varg);
/* copy value from varg for each element */
vector_resize(pvec_vector, t_count);
it_begin = vector_begin(pvec_vector);
it_end = vector_end(pvec_vector);
for (it_iter = it_begin; !iterator_equal(it_iter, it_end); it_iter = iterator_next(it_iter)) {
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_iter), pv_varg, &b_result);
assert(b_result);
}
/* destroy varg and free memory */
_vector_destroy_varg_value_auxiliary(pvec_vector, pv_varg);
_alloc_deallocate(&pvec_vector->_t_allocator, pv_varg, _GET_VECTOR_TYPE_SIZE(pvec_vector), 1);
}
void vector_push_back(struct vector_t* v, int value) {
if(v->index >= v->size)
{
vector_resize(v, 0);
}
v->data[v->index++] = value;
}
static void fasl_ensure_valid_table_index(lref_t reader, size_t index)
{
if (NULLP(FASL_READER_STREAM(reader)->table))
{
FASL_READER_STREAM(reader)->table =
vectorcons((index >=
DEFAULT_FASL_TABLE_SIZE) ? index +
DEFAULT_FASL_TABLE_SIZE : DEFAULT_FASL_TABLE_SIZE, NIL);
}
else
{
lref_t fasl_table = FASL_READER_STREAM(reader)->table;
assert(VECTORP(fasl_table));
size_t old_len = fasl_table->as.vector.dim;
if (index >= old_len)
{
size_t new_len =
(index >= old_len * 2) ? index + DEFAULT_FASL_TABLE_SIZE : (old_len * 2);
FASL_READER_STREAM(reader)->table =
vector_resize(fasl_table, new_len > SIZE_MAX ? SIZE_MAX : (size_t) new_len, NIL);
}
}
assert(VECTORP(FASL_READER_STREAM(reader)->table));
assert(index < (FASL_READER_STREAM(reader)->table)->as.vector.dim);
}
/**
* Assign vector element with an exist vector container range.
*/
void vector_assign_range(vector_t* pvec_vector, vector_iterator_t it_begin, vector_iterator_t it_end)
{
iterator_t it_dest;
iterator_t it_src;
bool_t b_result = false;
/* assign the two iterator is as the same type as pvec_vector */
assert(pvec_vector != NULL);
assert(_vector_is_inited(pvec_vector));
/*assert(!_vector_iterator_belong_to_vector(pvec_vector, it_begin));*/
/*assert(!_vector_iterator_belong_to_vector(pvec_vector, it_end));*/
assert(_vector_same_vector_iterator_type(pvec_vector, it_begin));
assert(_vector_same_vector_iterator_type(pvec_vector, it_end));
assert(iterator_equal(it_begin, it_end) || _vector_iterator_before(it_begin, it_end));
/* copy value from range [it_begin, it_end) for each element */
vector_resize(pvec_vector, iterator_distance(it_begin, it_end));
for(it_dest = vector_begin(pvec_vector), it_src = it_begin;
!iterator_equal(it_dest, vector_end(pvec_vector)) && !iterator_equal(it_src, it_end);
it_dest = iterator_next(it_dest), it_src = iterator_next(it_src))
{
b_result = _GET_VECTOR_TYPE_SIZE(pvec_vector);
_GET_VECTOR_TYPE_COPY_FUNCTION(pvec_vector)(_VECTOR_ITERATOR_COREPOS(it_dest), _VECTOR_ITERATOR_COREPOS(it_src), &b_result);
assert(b_result);
}
assert(iterator_equal(it_dest, vector_end(pvec_vector)) && iterator_equal(it_src, it_end));
}
JNIEXPORT void JNICALL Java_neuron_Neuron_vectorToHoc
(JNIEnv *env, jclass, jlong jc, jdoubleArray ja, jint size) {
Object* ho = (Object*)jc;
Vect* vec = (Vect*)ho->u.this_pointer;
vector_resize(vec, size);
env->GetDoubleArrayRegion(ja, 0, size, &vec->elem(0));
}
void vector_add(vector *vec, void *item) {
if ( vec->size == vec->total ) // It's full
vector_resize(vec, 2 * vec->total );
vec->item[vec->size] = item;
vec->size++;
}
size_t vector_push(struct vec *v, int item) {
if (v->sz == v->capacity)
if (!vector_resize(v)) return -1;
v->vals[v->sz++] = item;
return (v->sz - 1);
}
/*
* Given a string, split it at any of the provided separators to form a
* vector, copying each string segment. If the third argument isn't NULL,
* reuse that vector; otherwise, allocate a new one. Any number of
* consecutive separators are considered a single separator.
*/
struct vector *
vector_split_multi(const char *string, const char *seps,
struct vector *vector)
{
const char *p, *start;
size_t i, count;
vector = vector_reuse(vector);
count = split_multi_count(string, seps);
if (vector->allocated < count)
vector_resize(vector, count);
for (start = string, p = string, i = 0; *p != '\0'; p++)
if (strchr(seps, *p) != NULL) {
if (start != p)
vector->strings[i++] = xstrndup(start, p - start);
start = p + 1;
}
if (start != p)
vector->strings[i++] = xstrndup(start, p - start);
vector->count = i;
return vector;
}
//inserts obj into a new space at the end of v
void vector_append(Vector *v, LispObject *obj) {
if(v->size >= v->array_size)
vector_resize(v, 2);
v->array[v->end % v->array_size] = obj;
v->end++;
v->size++;
}
int vector_pop_back(struct vector_t* v) {
if(v->index > -1)
{
vector_resize(v);
return v->data[--v->index];
}
return -1;
}
/*
* Given a vector and a path to a program, exec that program with the vector
* as its arguments. This requires adding a NULL terminator to the vector and
* casting it appropriately.
*/
int
vector_exec(const char *path, struct vector *vector)
{
if (vector->allocated == vector->count)
vector_resize(vector, vector->count + 1);
vector->strings[vector->count] = NULL;
return execv(path, (char * const *) vector->strings);
}
void vector_push(Vector *vec, size_t elem)
{
if (vec->size >= vec->cap)
vector_resize(vec);
vec->data[vec->size] = elem;
vec->size++;
}
void * vector_pop(struct Vector * vector) {
if (vector->population == 0) {
return NULL;
}
void * elem = vector->storage[--vector->population];
vector_resize(vector);
return elem;
}
/**
* Initialize hashtable container.
*/
void _hashtable_init(_hashtable_t* pt_hashtable, size_t t_bucketcount, ufun_t ufun_hash, bfun_t bfun_compare)
{
assert(pt_hashtable != NULL);
assert(_hashtable_is_created(pt_hashtable));
/* initialize the bucket vector and node count */
vector_init(&pt_hashtable->_vec_bucket);
if (t_bucketcount > 0) {
vector_resize(&pt_hashtable->_vec_bucket, _hashtable_get_prime(t_bucketcount));
} else {
vector_resize(&pt_hashtable->_vec_bucket, _hashtable_get_prime(_HASHTABLE_DEFAULT_BUCKET_COUNT));
}
pt_hashtable->_t_nodecount = 0;
/* initialize the hash, compare and destroy element function */
pt_hashtable->_ufun_hash = ufun_hash != NULL ? ufun_hash : _hashtable_default_hash;
pt_hashtable->_bfun_compare = bfun_compare != NULL ? bfun_compare : _GET_HASHTABLE_TYPE_LESS_FUNCTION(pt_hashtable);
}
void
vector_init(vector *vec, size_t size)
{
vec->array = checked_malloc(INIT_SIZE * size);
vec->element_size = size;
vec->length = 0;
vec->max_length = INIT_SIZE;
vector_resize(vec);
}
// ----------------------------------------------------------------------------
vertex_buffer_t *
vertex_buffer_new_from_data( const char *format,
size_t vcount,
void *vertices,
size_t icount,
GLuint *indices )
{
vertex_buffer_t *self = vertex_buffer_new( format );
vector_resize( self->vertices, vcount );
assert( self->vertices->size == vcount);
memcpy( self->vertices->items, vertices, vcount*self->vertices->item_size );
vector_resize( self->indices, icount );
assert( self->indices->size == icount);
memcpy( self->indices->items, indices, icount*self->indices->item_size );
self->dirty = 1;
return self;
}
/*
* Add a new counted string to the vector, resizing the vector as necessary
* the same as with vector_add. This function is only available for vectors,
* not cvectors, since it requires the duplication of the input string to be
* sure it's nul-terminated.
*/
void
vector_addn(struct vector *vector, const char *string, size_t length)
{
size_t next = vector->count;
if (vector->count == vector->allocated)
vector_resize(vector, vector->allocated + 1);
vector->strings[next] = xstrndup(string, length);
vector->count++;
}
void
vector_append(vector *vec, void *obj, size_t size)
{
if (size != vec->element_size) {
fprintf(stderr, "Error: vector_append: unmatched type size.\n");
exit(1);
}
memcpy(vec->array + vec->length * vec->element_size, obj, size);
vec->length++;
vector_resize(vec);
}
vector getFileMask(WaveFile* waveFile, vector wave, int len, char marker = NULL)
{
vector mask;
ListChunk * listLablChunk = NULL;
ListChunk * listLtxtChunk = NULL;
qDebug() << "listCount " << waveFile->listCount << LOG_DATA;
for (int i=0; i<waveFile->listCount; i++)
{
ListChunk * listChunk = &(waveFile->listChunks[i]);
if (listChunk == NULL) continue;
qDebug() << "listChunk->lablCount " << listChunk->lablCount << LOG_DATA;
if (listChunk->lablChunks != NULL && listChunk->lablCount > 0)
{
listLablChunk = listChunk;
}
qDebug() << "listChunk->ltxtCount " << listChunk->ltxtCount << LOG_DATA;
if (listChunk->ltxtChunks != NULL && listChunk->ltxtCount > 0)
{
listLtxtChunk = listChunk;
}
}
bool tryFileData = (waveFile->cueChunk != NULL)
&& (littleEndianBytesToUInt16(waveFile->cueChunk->cuePointsCount) > 0)
&& (listLtxtChunk != NULL)
&& (listLtxtChunk->ltxtChunks != NULL)
&& (listLtxtChunk->ltxtCount > 0)
&& (listLablChunk != NULL)
&& (listLablChunk->lablChunks != NULL)
&& (listLablChunk->lablCount > 0);
if (tryFileData)
{
qDebug() << "tryFileData" << LOG_DATA;
vector mask_from_file = readMaskFromFile(waveFile, wave.x, marker);
vector mask_norm = normalizev(mask_from_file, MASK_MIN, MASK_MAX);
mask = vector_resize(mask_norm, len);
freev(mask_norm);
freev(mask_from_file);
qDebug() << "vector_resize" << LOG_DATA;
}
if (!tryFileData || !validateMask(mask)) {
qDebug() << "!tryFileData" << LOG_DATA;
mask = onesv(len);
}
return mask;
}
int vector_set(vector *v, int index, int item)
{
assert(v!=NULL);
if ( index >= v->n_items ) {
vector_resize(v, index+8);
}
if ( index < v->n_items ) {
v->items[index] = item;
}
return index < v->n_items;
}
void vector_set(Vector *vector, size_t index, Data value)
{
if (index > 0 && vector->size >= index) {
vector->container[index] = value;
vector->vSize = index + 1;
}
else {
vector_resize(vector, index + 1);
vector->container[index] = value;
}
}
void *_vector_push(struct vector *v, size_t elemsize)
{
if (v->count == v->allocated_count) {
if (!vector_grow(v)) {
return NULL;
}
}
vector_resize(v, v->count+1);
return _vector_get(v, elemsize, v->count-1);
}
int vector_pop_back(struct vector_t* v) {
if(v->index <= 0)
{
return INT_MAX;
}
if(v->index <= v->size / 2)
{
vector_resize(v, 1);
}
return v->data[--v->index];
}
//TODO: Do we care that this can fail?
void stack_push(struct stack *stack, void *elem)
{
if (!stack || !elem)
return;
if (stack->index == stack->vec.len) {
vector_resize(&stack->vec, stack->index * 2);
}
vector_set(&stack->vec, stack->index, elem);
stack->index++;
}
void test_realloc_resize() {
size_t n=10;
struct vector* v = vector_new(n, sizeof(struct test));
assert(v->size == n);
assert(v->capacity == n);
size_t new_n = 12;
vector_realloc(v, new_n);
assert(v->size == n);
assert(v->capacity == new_n);
new_n = 7;
vector_realloc(v, new_n);
assert(v->size == new_n);
assert(v->capacity == new_n);
size_t rsn = 6;
vector_resize(v,rsn);
assert(v->size == rsn);
assert(v->capacity == new_n);
rsn = 12;
vector_resize(v,rsn);
assert(v->size == rsn);
assert(v->capacity == rsn);
vector_clear(v);
assert(v->size == 0);
assert(v->capacity == rsn);
vector_freedata(v);
assert(v->size == 0);
assert(v->capacity == 0);
assert(v->d == NULL);
v = vector_delete(v);
assert(v == NULL);
}
void vector_push_back(vector_t *v, void *e)
{
void *base = v->finish;
v->finish += v->element_sz;
if(v->finish == v->end)
{
vector_resize(v);
base = v->finish - v->element_sz;
}
memcpy(base, e, v->element_sz);
}
int lp_add_var_without_A(LP* lp, char* name) {
/* 追加されるのは非負変数 */
/* 戻り値は追加された変数の番号 */
/* 応急処置です... matrix_add_column(lp->A) しない以外は lp_add_var()
と同じです. */
lp->vars ++;
lp->var_type = my_realloc(lp->var_type, lp->vars*sizeof(int));
lp->var_type[lp->vars-1] = LP_VAR_TYPE_NORMAL;
if(name != NULL) {
lp->var_name = my_realloc(lp->var_name, lp->vars*sizeof(char*));
lp->var_name[lp->vars-1] = my_malloc(LP_NAME_LEN_MAX*sizeof(char));
if (name == NULL || name[0] == 0) {
snprintf(lp->var_name[lp->vars-1], LP_NAME_LEN_MAX,
"v%d", lp->vars);
} else {
strncpy(lp->var_name[lp->vars-1], name, LP_NAME_LEN_MAX);
}
hash_str_find(lp->hash_str_var_name, name, lp->var_name, lp->vars-1);
}
vector_resize(lp->x, lp->vars);
vector_resize(lp->c, lp->vars);
vector_resize(lp->c_back, lp->vars);
lp->is_basis = my_realloc(lp->is_basis, lp->vars*sizeof(int));
lp->is_integer = my_realloc(lp->is_integer, lp->vars*sizeof(int));
lp->upper.is_valid = my_realloc(lp->upper.is_valid, lp->vars*sizeof(int));
lp->lower.is_valid = my_realloc(lp->lower.is_valid, lp->vars*sizeof(int));
lp->upper.bound = my_realloc(lp->upper.bound, lp->vars*sizeof(mpq_t));
lp->lower.bound = my_realloc(lp->lower.bound, lp->vars*sizeof(mpq_t));
lp->upper.is_valid[lp->vars-1] = FALSE;
lp->lower.is_valid[lp->vars-1] = TRUE;
mpq_init(lp->lower.bound[lp->vars-1]);
return lp->vars-1;
}
vector data_get_intensive_cutted(SimpleGraphData * data)
{
if (data->b_intensive_cutted == 0)
{
vector intensive = data_get_intensive(data);
vector pitch_log = data_get_pitch_log(data);
vector resized_pitch_log = vector_resize(pitch_log, intensive.x);
data->d_intensive_cutted = vector_cut_by_mask(intensive, resized_pitch_log);
freev(resized_pitch_log);
data->b_intensive_cutted = 1;
}
return data->d_intensive_cutted;
}
int vector_pop_back(struct vector_t* v) {
if(v->index==0)
{
printf("No elements left !\n");
return -1;
}
else
if(v->index < (v->size/2))
vector_resize(v);
if(v->index!=0)
return v->data[--v->index];
}
struct stack *stack_create(size_t size)
{
struct stack *stack;
stack = calloc(1, sizeof(*stack));
if (!stack)
return NULL;
stack->vec.size = size;
vector_resize(&stack->vec, 1);
return stack;
}
