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;
}
// ----------------------------------------------------------------------------
void
vertex_buffer_delete( vertex_buffer_t *self )
{
assert( self );
#ifdef BROKENVAO
if( self->vao_id )
glDeleteVertexArrays(1, &self->vao_id);
#endif
vector_delete( self->vertices );
self->vertices = 0;
if( self->vertices_id )
{
glDeleteBuffers( 1, &self->vertices_id );
}
self->vertices_id = 0;
vector_delete( self->indices );
self->indices = 0;
if( self->indices_id )
{
glDeleteBuffers( 1, &self->indices_id );
}
self->indices_id = 0;
if( self->format )
{
free( self->format );
}
self->format = 0;
self->dirty = 0;
free( self );
}
int main(void) {
int i;
vector v;
vector_init(&v);
vector_add(&v, "Bonjour");
vector_add(&v, "tout");
vector_add(&v, "le");
vector_add(&v, "monde");
for (i = 0; i < vector_total(&v); i++)
printf("%s ", (char *) vector_get(&v, i));
printf("\n");
vector_delete(&v, 3);
vector_delete(&v, 2);
vector_delete(&v, 1);
vector_set(&v, 0, "Hello");
vector_add(&v, "World");
for (i = 0; i < vector_total(&v); i++)
printf("%s ", (char *) vector_get(&v, i));
printf("\n");
vector_free(&v);
}
int main(void)
{
int i;
vector v;
vector_init(&v);
// char temp1[20]
vector_add(&v, 1);
vector_add(&v, 2);
vector_add(&v, 3);
vector_add(&v, 4);
for (i = 0; i < vector_total(&v); i++)
printf("%s ", (char *) vector_get(&v, i));
printf("\n");
vector_delete(&v, 3);
vector_delete(&v, 2);
vector_delete(&v, 1);
vector_set(&v, 0, "Hello");
vector_add(&v, "World");
for (i = 0; i < vector_total(&v); i++)
printf("%s ", (char *) vector_get(&v, i));
printf("\n");
vector_free(&v);
}
// ----------------------------------------------------------------------------
void
vertex_buffer_delete( vertex_buffer_t *self )
{
assert( self );
vector_delete( self->vertices );
self->vertices = 0;
if( self->vertices_id )
{
glDeleteBuffers( 1, &self->vertices_id );
}
self->vertices_id = 0;
vector_delete( self->indices );
self->indices = 0;
if( self->indices_id )
{
glDeleteBuffers( 1, &self->indices_id );
}
self->indices_id = 0;
if( self->format )
{
free( self->format );
}
self->format = 0;
self->dirty = 0;
free( self );
}
int main(void)
{
vector v;
vector_init(&v);
vector_add(&v, "emil");
vector_add(&v, "hannes");
vector_add(&v, "lydia");
vector_add(&v, "olle");
vector_add(&v, "erik");
int i;
printf("first round:\n");
for (i = 0; i < vector_count(&v); i++) {
printf("%s\n", vector_get(&v, i));
}
vector_delete(&v, 1);
vector_delete(&v, 3);
printf("second round:\n");
for (i = 0; i < vector_count(&v); i++) {
printf("%s\n", vector_get(&v, i));
}
vector_free(&v);
return 0;
}
/* 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);
}
int btree_delete_ex (PBTREE btree, int node_idx, long target_key) {
// target is just a package for the key value. the reference does not
// provide the address of the Elem instance to be deleted.
// first find the node contain the Elem instance with the given key
int parent_index_this = BTREE_INVALID_ELEMENT_IDX;
PBTREE_ELEMENT found;
int last_visted_node_idx;
if (node_idx == BTREE_INVALID_NODE_IDX)
node_idx = btree->root_node_idx;
last_visted_node_idx = node_idx;
found = btree_search_ex (btree, &last_visted_node_idx, target_key);
if (!found)
return 0;
if (is_leaf(btree, last_visted_node_idx) && key_count(btree, last_visted_node_idx) > btree_minimum_keys())
return vector_delete (btree, last_visted_node_idx, target_key);
else if (is_leaf(btree, last_visted_node_idx)) {
vector_delete (btree, last_visted_node_idx, target_key);
// loop invariant: if _node_ is not null_ptr, it points to a node
// that has lost an element and needs to import one from a sibling
// or merge with a sibling and import one from its parent.
// after an iteration of the loop, _node_ may become null or
// it may point to its parent if an element was imported from the
// parent and this caused the parent to fall below the minimum
// element count.
while (BTREE_IS_VALID_NODE_IDX(last_visted_node_idx)) {
int right, left;
// NOTE: the "this" pointer may no longer be valid after the first
// iteration of this loop!!!
if (last_visted_node_idx == find_root(btree) && is_leaf(btree, last_visted_node_idx))
break;
if (last_visted_node_idx == find_root(btree) && !is_leaf(btree, last_visted_node_idx)) // sanity check
return 0;
// is an extra element available from the right sibling (if any)
right = right_sibling(btree, last_visted_node_idx, &parent_index_this);
if (BTREE_IS_VALID_NODE_IDX(right) && key_count(btree, right) > btree_minimum_keys())
last_visted_node_idx = rotate_from_right(btree, last_visted_node_idx, parent_index_this);
else {
// is an extra element available from the left sibling (if any)
left = left_sibling(btree, last_visted_node_idx, &parent_index_this);
if (BTREE_IS_VALID_NODE_IDX(left) && key_count(btree, left) > btree_minimum_keys())
last_visted_node_idx = rotate_from_left(btree, last_visted_node_idx, parent_index_this);
else if (BTREE_IS_VALID_NODE_IDX(right))
last_visted_node_idx = merge_right(btree, last_visted_node_idx, parent_index_this);
else if (BTREE_IS_VALID_NODE_IDX(left))
last_visted_node_idx = merge_left(btree, last_visted_node_idx, parent_index_this);
}
}
}
else {
PBTREE_ELEMENT smallest_in_subtree = smallest_key_in_subtree(btree, found->subtree_node_idx);
found->key = smallest_in_subtree->key;
found->data_entry_idx = smallest_in_subtree->data_entry_idx;
btree_delete_ex (btree, found->subtree_node_idx, smallest_in_subtree->key);
}
return 1;
}
// ----------------------------------------------------------------------------
void
vertex_buffer_delete( vertex_buffer_t *self )
{
size_t i;
assert( self );
for( i=0; i<MAX_VERTEX_ATTRIBUTE; ++i )
{
if( self->attributes[i] )
{
vertex_attribute_delete( self->attributes[i] );
}
}
#ifdef FREETYPE_GL_USE_VAO
if( self->VAO_id )
{
//needs OpenGL ES 3.0
glDeleteVertexArrays( 1, &self->VAO_id );
}
self->VAO_id = 0;
#endif
vector_delete( self->vertices );
self->vertices = 0;
if( self->vertices_id )
{
glDeleteBuffers( 1, &self->vertices_id );
}
self->vertices_id = 0;
vector_delete( self->indices );
self->indices = 0;
if( self->indices_id )
{
glDeleteBuffers( 1, &self->indices_id );
}
self->indices_id = 0;
vector_delete( self->items );
if( self->format )
{
free( self->format );
}
self->format = 0;
self->state = 0;
free( self );
}
END_TEST
START_TEST (delete_element_should_fail_if_invalid_position)
{
char *sport1 = strdup("winsurf");
vector *v = vector_new(sizeof(char *), free_string, 5);
vector_append(v, &sport1);
fail_unless(vector_delete(v, 2) == VECT_DELETE_INVALID_POSITION);
fail_unless(vector_delete(v, -2) == VECT_DELETE_INVALID_POSITION);
vector_free(v);
}
static void vector_2(void) {
vector_t v;
CU_ASSERT(vector_init(&v, "my_vector.bin", 1) == 0);
CU_ASSERT(vector_size(&v) == 0);
CU_ASSERT(vector_pages(&v) == 0);
CU_ASSERT(vector_capacity(&v) == 0);
CU_ASSERT(vector_elem_size(&v) == 1);
CU_ASSERT(vector_size(&v, COUNT) == COUNT);
CU_ASSERT(COUNT <= vector_capacity(&v));
CU_ASSERT(COUNT <= vector_size(&v));
CU_ASSERT(3 <= vector_pages(&v));
for (int i=0; i<COUNT; i++) {
unsigned char c = (unsigned char)i;
crc2 = clib_crc32(c, crc2);
CU_ASSERT(vector_put(&v, i, &c) == 0);
}
CU_ASSERT_FATAL(crc2 != 0);
FILE * f = fopen(v.hdr.name, "w");
CU_ASSERT_FATAL(f != NULL);
CU_ASSERT(COUNT < vector_save(&v, f));
fclose(f), f = NULL;
CU_ASSERT(vector_delete(&v) == 0);
}
int main(int argc, char *argv[]) {
vector_t vec;
vector_init(&vec);
printf("vector initialised\n");
printf("vector size=%d\n", vec.size);
printf("vector capacity=%d\n", vec.capacity);
int i;
for (i = 0; i < 50; i++) {
vector_set(&vec, i * 2, i);
}
printf("vector size=%d\n", vec.size);
printf("vector capacity=%d\n", vec.capacity);
while (vec.size > 10) {
int v = vector_get(&vec, 0);
vector_delete(&vec, 0);
}
printf("vector size=%d\n", vec.size);
printf("vector capacity=%d\n", vec.capacity);
vector_set(&vec, vec.size, 100);
printf("vector size=%d\n", vec.size);
printf("vector capacity=%d\n", vec.capacity);
return 0;
}
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);
}
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);
}
int main(int argc, char **argv)
{
int t = 0;
for (int c; (c = getopt(argc, argv, "n:p:")) != -1;) {
switch(c) {
case 'n':
t = atoi(optarg);
break;
}
}
uint32_t result = 1;
vector(int) *vstep = vector_new(int, 100);
int i = 0;
int pivot = 1;
int base = 10;
while(i < 1000000) {
i += pivot * (base - base / 10);
++pivot;
base *= 10;
vector_pushback(vstep, i);
}
for(base = 1; base <= 1000000; base *= 10) {
if(t > 0) base = t;
i = 1;
int last = 0;
vector_closure(vstep, pivot) {
if(base <= pivot) break;
i++;
last = pivot;
}
int pbase;
pbase = POW(10, i - 1) - 1;
int ofs = (base - last);
ofs = (ofs % i == 0) ? ofs / i : ofs / i+ 1;
int num = pbase + ofs;
int dn;
int dofs = (i - (base - last) % i) % i;
DUMPD(dofs);
dn = num / POW(10, dofs);
dn %= 10;
DUMPD(base);
DUMPD(dn);
result *= dn;
if(t > 0) break;
}
DUMPD(result);
vector_delete(vstep);
return 0;
}
static void vector_4(void) {
vector_t v;
if (vector_init(&v, NULL, 0) < 0) {
err_t * err = err_get();
fprintf(stderr, "%s(%d): UNEXPECTED: %.*s\n",
err_file(err), err_line(err), err_size(err),
(const char *)err_data(err));
}
if (vector_init(&v, "my_vector", 0) < 0) {
err_t * err = err_get();
fprintf(stderr, "%s(%d): UNEXPECTED: %.*s\n",
err_file(err), err_line(err), err_size(err),
(const char *)err_data(err));
}
for (size_t i=VECTOR_ELEM_MIN; i<=VECTOR_ELEM_MAX; i+=3) {
vector_init(&v, "my_vector", i);
CU_ASSERT(vector_size(&v) == 0);
CU_ASSERT(vector_pages(&v) == 0);
CU_ASSERT(vector_capacity(&v) == 0);
CU_ASSERT(vector_elem_size(&v) == i);
CU_ASSERT(vector_elem_size(&v) * v.hdr.elem_num <= v.hdr.page_size);
vector_size(&v, COUNT);
CU_ASSERT(vector_size(&v) == COUNT);
CU_ASSERT(vector_size(&v) <= vector_capacity(&v));
CU_ASSERT(0 < vector_pages(&v));
vector_delete(&v);
}
}
static void vector_3(void) {
vector_t v;
vector_init(&v, __func__, 1);
CU_ASSERT(vector_size(&v) == 0);
CU_ASSERT(vector_pages(&v) == 0);
CU_ASSERT(vector_capacity(&v) == 0);
CU_ASSERT(vector_elem_size(&v) == 1);
FILE * f = fopen("my_vector.bin", "r");
CU_ASSERT_FATAL(f != NULL);
CU_ASSERT(COUNT < vector_load(&v, f));
fclose(f), f = NULL;
crc3 = 0;
for (int i=0; i<COUNT; i++) {
unsigned char c;
vector_get(&v, i, &c);
crc3 = clib_crc32(c, crc3);
}
CU_ASSERT_FATAL(crc3 != 0);
CU_ASSERT_FATAL(crc2 == crc3);
vector_delete(&v);
}
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);
}
// --------------------------------------------------- texture_glyph_delete ---
void
texture_glyph_delete( texture_glyph_t *self )
{
assert( self );
vector_delete( self->kerning );
free( self );
}
/* 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);
}
static void free_config (struct config_s *conf)
{
safefree (conf->config_file);
safefree (conf->logf_name);
safefree (conf->stathost);
safefree (conf->user);
safefree (conf->group);
vector_delete(conf->listen_addrs);
#ifdef FILTER_ENABLE
safefree (conf->filter);
#endif /* FILTER_ENABLE */
#ifdef REVERSE_SUPPORT
free_reversepath_list(conf->reversepath_list);
safefree (conf->reversebaseurl);
#endif
#ifdef UPSTREAM_SUPPORT
free_upstream_list (conf->upstream_list);
#endif /* UPSTREAM_SUPPORT */
safefree (conf->pidpath);
safefree (conf->bind_address);
safefree (conf->via_proxy_name);
hashmap_delete (conf->errorpages);
free_added_headers (conf->add_headers);
safefree (conf->errorpage_undef);
safefree (conf->statpage);
flush_access_list (conf->access_list);
free_connect_ports_list (conf->connect_ports);
hashmap_delete (conf->anonymous_map);
memset (conf, 0, sizeof(*conf));
}
void config_delete(config_t c)
{
for (int i = 0; i < vector_size(c); ++i)
{
free(c[i].name);
}
vector_delete(c);
}
int main(int argc, char **argv) {
vector_t *v;
printf("Calling vector_new()\n");
v = vector_new();
printf("Calling vector_delete()\n");
vector_delete(v);
printf("vector_new() again\n");
v = vector_new();
printf("These should all return 0 (vector_get()): ");
printf("%d ", vector_get(v, 0));
printf("%d ", vector_get(v, 1));
printf("%d\n", vector_get(v, 2));
printf("Doing a bunch of vector_set()s\n");
vector_set(v, 0, 98);
vector_set(v, 11, 15);
vector_set(v, 15, -23);
vector_set(v, 24, 65);
vector_set(v, 500, 3);
vector_set(v, 12, -123);
vector_set(v, 15, 21);
vector_set(v, 25, 43);
printf("These should be equal:\n");
printf("98 = %d\n", vector_get(v, 0));
printf("15 = %d\n", vector_get(v, 11));
printf("65 = %d\n", vector_get(v, 24));
printf("-123 = %d\n", vector_get(v, 12));
printf("21 = %d\n", vector_get(v, 15));
printf("43 = %d\n", vector_get(v, 25));
printf("0 = %d\n", vector_get(v, 23));
printf("0 = %d\n", vector_get(v, 1));
printf("0 = %d\n", vector_get(v, 501));
printf("3 = %d\n", vector_get(v, 500));
vector_delete(v);
printf("Test complete.\n");
return 0;
}
int vector_test(void)
{
vector v = vector_new(5);
int i;
for (i=0; i<5; i++) assert(vector_set(&v, i, i*10));
for (i=5; i<10; i++) assert(vector_set(&v, i, i*10));
for (i=0; i<10; i++) printf("item[%i] = %i\n", i, v.items[i]);
vector_delete(&v);
}
// ----------------------------------------------------------------------------
void
text_buffer_delete( text_buffer_t * self )
{
vector_delete( self->lines );
font_manager_delete( self->manager );
vertex_buffer_delete( self->buffer );
glDeleteProgram( self->shader );
free( self );
}
void ast_tree_recursive_clear(struct ast_tree_t *t) {
size_t i, len = t->children->size;
for (i = 0; i < len; i++) {
ast_recursive_delete(vector_get(t->children, i));
}
vector_delete(t->children);
t->children = NULL;
}
// ----------------------------------------------------------------------------
void
vertex_buffer_delete( vertex_buffer_t *self )
{
size_t i;
assert( self );
for( i=0; i<MAX_VERTEX_ATTRIBUTE; ++i )
{
if( self->attributes[i] )
{
vertex_attribute_delete( self->attributes[i] );
}
}
vector_delete( self->vertices );
self->vertices = 0;
if( self->vertices_id )
{
glDeleteBuffers( 1, &self->vertices_id );
}
self->vertices_id = 0;
vector_delete( self->indices );
self->indices = 0;
if( self->indices_id )
{
glDeleteBuffers( 1, &self->indices_id );
}
self->indices_id = 0;
vector_delete( self->items );
if( self->format )
{
free( self->format );
}
self->format = 0;
self->state = 0;
free( self );
}
/* computes SVD: M = U*S*V^T; note Vt = V^T */
void singular_value_decomposition(mat *M, mat *U, mat *S, mat *Vt){
int m,n,k;
m = M->nrows; n = M->ncols;
k = min(m,n);
vec * svals = vector_new(k);
//LAPACKE_dgesvd( LAPACK_COL_MAJOR, 'S', 'S', m, n, M->d, m, svals->d, U->d, m, Vt->d, k, work->d );
culaDgesvd('S', 'S', m, n, M->d, m, svals->d, U->d, m, Vt->d, k);
initialize_diagonal_matrix(S, svals);
vector_delete(svals);
}
static void delete_session(struct libwebsocket *wsi) {
int count = vector_count(sessions);
for (int i = 0; i < count; i++) {
server_session_t *s = vector_get(sessions, i);
if (s != NULL && s->wsi == wsi) {
vector_delete(sessions, i);
break;
}
}
}
/* copy the first k columns of M into M_out where k = M_out->ncols (M_out pre-initialized) */
void matrix_copy_first_columns(mat *M_out, mat *M){
int i,k;
k = M_out->ncols;
vec * col_vec;
for(i=0; i<k; i++){
col_vec = vector_new(M->nrows);
matrix_get_col(M,i,col_vec);
matrix_set_col(M_out,i,col_vec);
vector_delete(col_vec);
}
}
