Esempio n. 1
0
int main(int argc, char *argv[]) {
  Point myPoint = point_new(0.0, 0.0);
  Vector unitX = vector_new(1.0, 0.0);
  Vector unitY = vector_new(0.0, 1.0);

  printf("%s + %s + %s = ", point_toString(myPoint),
                            vector_toString(unitX),
                            vector_toString(unitY) );

  point_addVector(myPoint, unitX);
  point_addVector(myPoint, unitY);

  printf("As a tuple: %s\n", tuple_toString((Tuple)myPoint));
  printf("As a point: %s\n", point_toString(myPoint));

  printf( "After scaling unitX by -0.5: %s\n",
	  vector_toString(vector_scale(unitX, -0.5))
	);
  printf("unitX has length %lf\n", vector_length(unitX));

  vector_delete(unitX);
  vector_delete(unitY);
  point_delete(myPoint);

  return 0;
}
Esempio n. 2
0
static void		init_vector(t_svr_vector *vec, t_select *slt)
{
  vec->slt = slt;
  vec->client = vector_new(NULL);
  vec->action = vector_new(NULL);
  vec->graph = vector_new(NULL);
}
void hashmap_new(hashmap* hm, int elem_size, int num_buckets, hashmap_hash_fun hash_fun, hashmap_compare_fun compare_fun, hashmap_free_fun free_fun, key_type type)
{
	assert(elem_size > 0 || num_buckets > 0 || hash_fun != NULL || compare_fun != NULL);

	if ((hm->pairs = malloc((num_buckets + 1) * sizeof(vector))) == NULL) {
		printf("memory allocation error in hm->pairs creation.\n");
		exit(0);
	}

	// Problem with position initilization at 0, so i use a dirty solution, added 1 in
	// some places, but no in hm->num_buckets, for simpliest code.
	for (int i = 1; i < num_buckets + 1; ++i)
		vector_new(hm->pairs + i, sizeof(pair), free_fun, 4);

	if ((hm->used_buckets = malloc(sizeof(vector))) == NULL) {
		printf("memory allocation error in hm->used_buckets creation.\n");
		return ;
	}
	vector_new(hm->used_buckets, sizeof(int), NULL, 4);

	hm->k_type = type;
	hm->pairs->elem_size = sizeof(vector);
	hm->num_buckets = num_buckets;
	hm->compare_fun = compare_fun;
	hm->free_fun = free_fun;
	hm->hash_fun = hash_fun;
	hm->value_size = elem_size;
}
/* build orthonormal basis matrix
Q = Y;
for j=1:k
    vj = Q(:,j);
    for i=1:(j-1)
        vi = Q(:,i);
        vj = vj - project_vec(vj,vi);
    end
    vj = vj/norm(vj);
    Q(:,j) = vj;
end
*/
void build_orthonormal_basis_from_mat(mat *A, mat *Q){
    int m,n,i,j,ind,num_ortos=2;
    double vec_norm;
    vec *vi,*vj,*p;
    m = A->nrows;
    n = A->ncols;
    vi = vector_new(m);
    vj = vector_new(m);
    p = vector_new(m);
    matrix_copy(Q, A);

    for(ind=0; ind<num_ortos; ind++){
        for(j=0; j<n; j++){
            matrix_get_col(Q, j, vj);
            for(i=0; i<j; i++){
                matrix_get_col(Q, i, vi);
                project_vector(vj, vi, p);
                vector_sub(vj, p);
            }
            vec_norm = vector_get2norm(vj);
            vector_scale(vj, 1.0/vec_norm);
            matrix_set_col(Q, j, vj);
        }
    }
    vector_delete(vi);
    vector_delete(vj);
    vector_delete(p);
}
Esempio n. 5
0
File: ray.c Progetto: gmpetrov/RT
t_ray	*ray_new(void)
{
	t_ray	*rayon;

	rayon = (t_ray	*)malloc(sizeof(t_ray));
	rayon->o = vector_new(0, 0, 0);
	rayon->d = vector_new(0, 0, 0);
	return (rayon);
}
Esempio n. 6
0
// ----------------------------------------------------------------------------
vertex_buffer_t *
vertex_buffer_new( const char *format )
{
    size_t i, index = 0, stride = 0;
    const char *start = 0, *end = 0;
    char *pointer = 0;

    vertex_buffer_t *self = (vertex_buffer_t *) malloc (sizeof(vertex_buffer_t));
    if( !self )
    {
        return NULL;
    }

    self->format = strdup( format );

    for( i=0; i<MAX_VERTEX_ATTRIBUTE; ++i )
    {
        self->attributes[i] = 0;
    }

    start = format;
    do
    {
        end = (char *) (strchr(start+1, ':'));
        char *desc = 0;
        if (end == NULL)
        {
            desc = strdup(start);
        }
        else
        {
            desc = strdup(start);
            desc[end-start] = '0';
        }
        vertex_attribute_t *attribute = vertex_attribute_parse( desc );
        start = end+1;
        free(desc);
        attribute->pointer = pointer;
        stride += attribute->size*GL_TYPE_SIZE( attribute->type );
        pointer+= attribute->size*GL_TYPE_SIZE( attribute->type );
        self->attributes[index] = attribute;
        index++;
    } while ( end && (index < MAX_VERTEX_ATTRIBUTE) );

    for( i=0; i<index; ++i )
    {
        self->attributes[i]->stride = stride;
    }

    self->vertices = vector_new( stride );
    self->vertices_id  = 0;
    self->indices = vector_new( sizeof(GLuint) );
    self->indices_id  = 0;
    self->dirty = 1;
    return self;
}
Esempio n. 7
0
File: tx.c Progetto: afk11/libbtc
btc_tx* btc_tx_new()
{
    btc_tx* tx;
    tx = calloc(1, sizeof(*tx));
    tx->vin = vector_new(8, btc_tx_in_free_cb);
    tx->vout = vector_new(8, btc_tx_out_free_cb);
    tx->version = 1;
    tx->locktime = 0;
    return tx;
}
Esempio n. 8
0
void
module_init()
{
    ModuleList = vector_new(0, sizeof(Module));
    ModulePaths = vector_new(0, sizeof(char *));
    ModuleSection = config_register_section("module", false);

    config_register_field(ModuleSection, "path", json_type_string,
                          module_config_set_path);
}
Esempio n. 9
0
END_TEST

START_TEST (new_should_return_error_if_invalid_elem_size_or_initial)
{
  vector *v;

  v = vector_new(0, NULL, 10);
  fail_unless(v == NULL, "should fail if invalid size");

  v = vector_new(sizeof(int), NULL, 0);
  fail_unless(v == NULL, "should fail if invalid initial");

  vector_free(v);
}
Esempio n. 10
0
void run() {
    int t = 0;
    vector* stack = vector_new(100);
    vector_push(stack, (void*)0);
    while (1) {
        t = cur_token();
        action a = table[(int)vector_peek(stack)][t];
        if (a.action == 's') {
            vector_push(stack, (void*)a.attr);
            index++;
            printf("shift %d\n", a.attr);
        } else if (a.action == 'r') {
            for (int i=0; i<rules[a.attr][0]-1; i++)
                vector_pop(stack);
            int head_of_production = rules[a.attr][1];
            int top_of_stack = (int)vector_peek(stack);
            int new_state = table[top_of_stack][head_of_production].attr;
            vector_push(stack, (void*)new_state);
            printf("Reduce by rule %d\n", a.attr);
            printf("Stack top: %d\n", (int)vector_peek(stack));
        } else if (a.action == 'a') {
            printf("Accept\n");
            break;
        } else {
            error("Parsing failed", "");
        }
    }
}
Esempio n. 11
0
void hashset_add(Hashset *self, const char *key) {
    assert(self);
    assert(key);

    u64 hash = _hashset_djb2(key);
    u32 index = _hashset_index(self, key);
    Vector *bucket = NULL;

    if (!self->buckets[index]) {
        self->buckets[index] = vector_new(8, free);
    }

    bucket = self->buckets[index];

    for (u32 i = 0; i < bucket->size; ++i) {
        void *pkvp = vector_index(bucket, i);

        HashsetNode *kvp = (HashsetNode *)pkvp;

        // key already exists in hashset, set it to true and return success
        if (kvp->key == hash) {
            kvp->value = true;
            return;
        }
    }

    HashsetNode *kvp = (HashsetNode *)calloc(1, sizeof(HashsetNode));
    kvp->key = hash;
    kvp->value = true;
    vector_add(bucket, kvp);
}
Esempio n. 12
0
text_buffer_t *
text_buffer_new_with_program( size_t depth,
                                    GLuint program )
{
    text_buffer_t *self = (text_buffer_t *) malloc (sizeof(text_buffer_t));
    self->buffer = vertex_buffer_new(
                                     "vertex:3f,tex_coord:2f,color:4f,ashift:1f,agamma:1f" );
    self->manager = font_manager_new( 512, 512, depth );
    self->shader = program;
    self->shader_texture = glGetUniformLocation(self->shader, "tex");
    self->shader_pixel = glGetUniformLocation(self->shader, "pixel");
    self->line_start = 0;
    self->line_ascender = 0;
    self->base_color.r = 0.0;
    self->base_color.g = 0.0;
    self->base_color.b = 0.0;
    self->base_color.a = 1.0;
    self->line_descender = 0;
    self->lines = vector_new( sizeof(line_info_t) );
    self->bounds.left   = 0.0;
    self->bounds.top    = 0.0;
    self->bounds.width  = 0.0;
    self->bounds.height = 0.0;
    return self;
}
Esempio n. 13
0
vector_t * vector_deep_copy(vector_t * vector, libcontain_copy_func_t vector_valcopy_func)
{
	size_t i;
	size_t size;
	vector_t * retval;
	void * val;

	rw_spinlock_read_lock(vector->lock);
	do
	{
		size = vector->size;
	} while (!size);
	retval = vector_new(size);
	if (!retval)
		goto abort_vector_deep_copy1;
	for (i = 0; i < size; i++)
	{
		val = vector_get(vector, i);
		if (val != NULL)
			if (vector_put(retval, i, vector_valcopy_func(vector->nodes[i].val)) != 0)
				goto abort_vector_deep_copy2;
	}
	rw_spinlock_read_unlock(vector->lock);

	return retval;

abort_vector_deep_copy2:
	vector_free(retval);
abort_vector_deep_copy1:
	rw_spinlock_read_unlock(vector->lock);
	return NULL;
}
Esempio n. 14
0
vector *ol_bulk_unjar(ol_database *db, const ol_key_array keys, const size_t num_keys) {
    ol_transaction *tx = NULL;
    vector *to_return = NULL;
    check(db != NULL, "Cannot unjar on NULL database.");
    check((tx = olt_begin(db)) != NULL, "Could not begin transaction.");

    to_return = vector_new(sizeof(unsigned char *), 256);

    unsigned int i;
    for (i = 0; i < num_keys; i++) {
        const char *key = keys[i];
        unsigned char *item = NULL;
        size_t item_size = 0;
        olt_unjar(tx, key, strnlen(key, KEY_SIZE), &item, &item_size);

        if (item != NULL) {
            vector_append_ptr(to_return, item);
        } else {
            vector_append_ptr(to_return, NULL);
        }
    }

    check(olt_commit(tx) == 0, "Could not commit unjar transaction.");

    return to_return;

error:
    return NULL;
}
Esempio n. 15
0
void			ft_set_plan(t_data *data, char **line, int fd)
{
	int			cons;
	char		ref;

	data->origin = '0';
	data->color = '0';
	data->co = '0';
	ref = 0;
	while (ft_strcmp("#end_object", *line) != 0)
	{
		if (ft_strcmp("#const", *line) == 0 && (data->co = '1'))
			ft_set_plan_const(&cons, line, fd);
		else if (ft_strcmp("#origin", *line) == 0 && (data->origin = '1'))
			ft_set_plan_origin(data, line, fd);
		else if (ft_strcmp("#color", *line) == 0 && (data->color = '1'))
			ft_set_plan_color(data, line, fd);
		else if (ft_strcmp("#ref", *line) == 0)
			ft_set_plan_ref(&ref, line, fd);
		if (get_next_line(fd, line) <= 0)
			ft_error("[ERROR OBJECT] - Object plan has no end");
	}
	if (data->origin == '0' || data->co == '0' || data->color == '0')
		ft_error("[ERROR OBJECT] - Plan's spec missing");
	plan_new(vector_new(data->x, data->y, data->z), cons
	, color_set((int)data->x2, (int)data->y2, (int)data->z2, ref));
}
/* Performs [Q,R] = qr(M,'0') compact QR factorization 
M is mxn ; Q is mxn ; R is min(m,n) x min(m,n) */ 
void compact_QR_factorization(mat *M, mat *Q, mat *R){
    int i,j,m,n,k;
    m = M->nrows; n = M->ncols;
    k = min(m,n);
    mat *R_full = matrix_new(m,n);
    matrix_copy(R_full,M);
    vec *tau = vector_new(m);

    // get R
    //LAPACKE_dgeqrf(CblasRowMajor, m, n, R_full->d, n, tau->d);
    culaDgeqrf(m, n, R_full->d, m, tau->d);
    
    for(i=0; i<k; i++){
        for(j=0; j<k; j++){
            if(j>=i){
                matrix_set_element(R,i,j,matrix_get_element(R_full,i,j));
            }
        }
    }

    // get Q
    matrix_copy(Q,R_full); 
    //LAPACKE_dorgqr(CblasRowMajor, m, n, n, Q->d, n, tau->d);
    culaDorgqr(m, n, n, Q->d, m, tau->d);

    // clean up
    matrix_delete(R_full);
    vector_delete(tau);
}
Esempio n. 17
0
struct vector* vector_normalize(struct vector* v) {
    struct vector* vnorm = vector_new(v->length);
    double norm = vector_norm(v);
    assert(norm != 0);
    vector_normalize_into(vnorm, v);
    return vnorm;
}
Esempio n. 18
0
END_TEST

START_TEST (delete_element_should_shift_elements)
{

  char *sport1 = strdup("winsurf");
  char *sport2 = strdup("kitesurf");
  char *sport3 = strdup("motocross");
  char *sport4 = strdup("surf");

  vector *v = vector_new(sizeof(char *), free_string, 5);
  vector_append(v, &sport1);
  vector_append(v, &sport2);
  vector_append(v, &sport3);
  vector_append(v, &sport4);

  fail_unless(vector_delete(v, 1) == VECT_OK);
  fail_unless(vector_length(v) == 3);

  char *elem0 = *(char **)vector_get(v, 0);
  char *elem1 = *(char **)vector_get(v, 1);
  char *elem2 = *(char **)vector_get(v, 2);

  fail_unless(elem0 == sport1, "element on `0' should continue there. found '%s'", elem0);
  fail_unless(elem1 == sport3, "element on `2' should go to `1'. found '%s'", elem1);
  fail_unless(elem2 == sport4, "element on `3' should go to `2'. found '%s'", elem2);

  vector_free(v);
}
Esempio n. 19
0
END_TEST

START_TEST (append_should_grown_if_needed)
{

  int num1 = 10, num2 = 20, num3 = 30, num4 = 40;
  int *found1, *found2, *found3, *found4;

  vector *v = vector_new(sizeof(int *), NULL, 2);
  vector_append(v, &num1);
  vector_append(v, &num2);
  vector_append(v, &num3);   /* grow before append */
  vector_append(v, &num4);

  found1 = vector_get(v, 0);
  found2 = vector_get(v, 1);
  found3 = vector_get(v, 2);
  found4 = vector_get(v, 3);

  fail_unless(vector_length(v) == 4, "length should be 4");
  fail_unless(v->alloc_length == 4, ".alloc_length should be 10");
  fail_unless(*found1 == 10, "element 0 should be 10 not %d", *found1);
  fail_unless(*found2 == 20, "element 1 should be 20 not %d", *found2);
  fail_unless(*found3 == 30, "element 2 should be 30 not %d", *found3);
  fail_unless(*found4 == 40, "element 3 should be 40 not %d", *found4);

  vector_free(v);
}
Esempio n. 20
0
struct vector* vector_scalar_multiply(struct vector* v, double s) {
    struct vector* w = vector_new(v->length);
    for(int i = 0; i < v->length; i++) {
        VECTOR_IDX_INTO(w, i) = VECTOR_IDX_INTO(v, i) * s;
    }
    return w;
}
Esempio n. 21
0
int main (int argc, char **argv)
{
    int error = 0;
    Vector *vector = vector_new ();
    
    if (vector_load_from_file (vector, argc, argv))
    {
        Stopwatch *stopwatch = stopwatch_new ();
        uint64_t inversions = 0;

        stopwatch_start (stopwatch);
        
        inversions = count_inversions (vector);
        
        stopwatch_stop (stopwatch);
        
        printf ("%llu inversions of %zu numbers in %llu.%03u ms.\n", inversions, vector->length, stopwatch->elapsed, stopwatch->usec);
        
        stopwatch_free (stopwatch);
    }
    else
    {
        error = 1;
    }
    
    vector_free (vector);
    
    return error;
}
Esempio n. 22
0
/* ------------------------------------------------------------------------- */
TextureAtlas *
texture_atlas_new( size_t width, size_t height, size_t depth )
{
    assert( (depth == 1) || (depth == 3) );

    TextureAtlas *self = (TextureAtlas *) malloc( sizeof(TextureAtlas) );
    if( !self )
    {
        return NULL;
    }
    self->nodes = vector_new( sizeof(Node) );
    self->used = 0;
    self->width = width;
    self->height = height;
    self->depth = depth;
    Node node = {0,0,width};
    vector_push_back( self->nodes, &node );
    self->texid = 0;
    self->data = (unsigned char *)
        calloc( width*height*depth, sizeof(unsigned char) );

    // This is a special region that is used for background and underlined
    // decorations of glyphs
    int n = 4;
    unsigned char buffer[n*n];
    memset(buffer, 255, n*n);
    Region1 r = texture_atlas_get_region( self, n, n );
    texture_atlas_set_region( self, r.x, r.y, r.width, r.height, buffer, 1);
    self->black.x     = r.x + 1;
    self->black.y     = r.y + 1;
    self->black.width = r.width - 2;
    self->black.height= r.height - 2;

    return self;
}
Esempio n. 23
0
int main(int argc, char *argv[]) {
  Point myPoint = point_new(0.0, 0.0);
  Vector unitX = vector_new(1.0, 0.0);
  Vector unitY = vector_new(0.0, 1.0);

  printf("%s + %s + %s = ", point_toString(myPoint),
                            vector_toString(unitX),
                            vector_toString(unitY) );

  point_addVector(&myPoint, unitX);
  point_addVector(&myPoint, unitY);

  printf("%s\n", point_toString(myPoint));

  return 0;
}
Esempio n. 24
0
File: test.c Progetto: esheldon/misc
void test_sort() {
    struct vector* v = vector_new(7, sizeof(struct test));

    struct test* t = NULL;

    t = vector_get(v,0);
    t->id = 4;
    t = vector_get(v,1);
    t->id = 1;
    t = vector_get(v,2);
    t->id = 2;
    t = vector_get(v,3);
    t->id = 0;
    t = vector_get(v,4);
    t->id = 3;
    t = vector_get(v,5);
    t->id = 6;
    t = vector_get(v,6);
    t->id = 5;

    vector_sort(v, &compare_test);

    size_t i=0;
    struct test* iter = vector_front(v);
    struct test* end  = vector_end(v);
    while (iter != end) {
        assert(iter->id == i);
        iter++;
        i++;
    }
}
Esempio n. 25
0
struct point_hash* point_hash_new(int64 hpixid) {
    struct point_hash* pth = 
        alloc_or_die(sizeof(struct point_hash),"hash entry");
    pth->points = vector_new(0,sizeof(struct point*));
    pth->hpixid=hpixid;
    return pth;
}
Esempio n. 26
0
/* allocates the vector, and wraps it up into a data structure that 
ruby can understand */
static VALUE vector_alloc(VALUE klass) {
  Vector *vector;
  VALUE obj;
  vector = vector_new();
  obj = Data_Wrap_Struct(klass, 0, vector_free, vector);
  return obj;
}
Esempio n. 27
0
File: test.c Progetto: esheldon/misc
void test_pushpop() {
    struct vector* v = vector_new(0, sizeof(struct test));

    size_t i=0;
    size_t n=10;
    struct test t;
    for (i=0; i<n; i++) {
        t.id = i;
        t.x = 2*i;
        vector_push(v, &t);
    }

    struct test *tptr=NULL;
    for (i=0; i<n; i++) {
        tptr = vector_get(v,i);
        assert(tptr->id == i);
        assert(tptr->x == 2*i);
    }

    i=n-1;
    while (NULL != (tptr=vector_pop(v))) {
        assert(tptr->id == i);
        assert(tptr->x == 2*i);
        i--;
    }

    assert(v->size == 0);
    assert(v->capacity >= n);

    v = vector_delete(v);
    assert(v == NULL);
}
Esempio n. 28
0
int main() 
{
    /* Create the vector */
    vector *v = vector_new(3);
    printf("Vector size: %d\n", vector_size(v));

    /* Add elements to the vector */
    vector_push(v, (void*)0);
    vector_push(v, (void*)11);
    vector_push(v, (void*)22);
    printf("Vector size: %d\n", vector_size(v));
    vector_push(v, (void*)33);
    vector_push(v, (void*)44);
    vector_push(v, (void*)55);
    vector_push(v, (void*)66);

    /* Get the size and print the elements */
    printf("Vector size: %d\n", vector_size(v));
    printf("Element 1: %d\n", vector_get(v, 0));
    printf("Element 2: %d\n", vector_get(v, 1));
    printf("Element 3: %d\n", vector_get(v, 2));
    printf("Element 4: %d\n", vector_get(v, 3));
    printf("Element 5: %d\n", vector_get(v, 4));
    printf("Element 6: %d\n", vector_get(v, 5));
    printf("Element 7: %d\n", vector_get(v, 6));

    /* Clear vector and print the size */
    vector_clear(v);
    printf("Vector size: %d\n", vector_size(v));

    /* We have not destructor at C, so clean up memory by ourselves */
    vector_free(v);

    return 0;
}
Esempio n. 29
0
// ------------------------------------------------------ texture_glyph_new ---
texture_glyph_t *
texture_glyph_new( void )
{
    texture_glyph_t *self = (texture_glyph_t *) malloc( sizeof(texture_glyph_t) );
    if( self == NULL)
    {
        fprintf( stderr,
                 "line %d: No more memory for allocating data\n", __LINE__ );
        exit( EXIT_FAILURE );
    }
    self->id        = 0;
    self->width     = 0;
    self->height    = 0;
    self->outline_type = 0;
    self->outline_thickness = 0.0;
    self->offset_x  = 0;
    self->offset_y  = 0;
    self->advance_x = 0.0;
    self->advance_y = 0.0;
    self->s0        = 0.0;
    self->t0        = 0.0;
    self->s1        = 0.0;
    self->t1        = 0.0;
    self->kerning   = vector_new( sizeof(kerning_t) );
    return self;
}
Esempio n. 30
0
File: test.c Progetto: esheldon/misc
void test_long() {

    struct vector* v = vector_new(0, sizeof(long));
    long n=10;
    long i=0;
    for (i=0; i<n; i++) {
        vector_push(v, &i);
    }

    long* iter = vector_front(v);
    long* end  = vector_end(v);
    i=0;
    while (iter != end) {
        assert(i == *iter);
        iter++;
        i++;
    }

    long* lptr = vector_get(v,3);
    assert(3 == *lptr);

    lptr = vector_pop(v);
    assert((n-1) == *lptr);

    v=vector_delete(v);
    assert(v==NULL);
}