ne_dyn_vec.c

/*===========================================================================
 NetEvo Foundation Library
 Copyright (C) 2009, 2010 Thomas E. Gorochowski <tgorochowski@me.com>
 Bristol Centre for Complexity Sciences, University of Bristol, Bristol, UK
 ---------------------------------------------------------------------------- 
 NetEvo is a computing framework designed to allow researchers to investigate 
 evolutionary aspects of dynamical complex networks. By providing tools to 
 easily integrate each of these factors in a coherent way, it is hoped a 
 greater understanding can be gained of key attributes and features displayed 
 by complex systems.
 
 NetEvo is open-source software released under the Open Source Initiative 
 (OSI) approved Non-Profit Open Software License ("Non-Profit OSL") 3.0. 
 Detailed information about this licence can be found in the COPYING file 
 included as part of the source distribution.
 
 This library is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 ============================================================================*/


#include "ne_dyn_vec.h"
#include <stdlib.h>


ne_dyn_vec_t * ne_dyn_vec_alloc (int dataSize)
{  
   int i;
   ne_dyn_vec_t * vec = NULL;
   
   vec = (ne_dyn_vec_t *)malloc(sizeof(ne_dyn_vec_t));
   
   /* Set initial sizes */
   vec->curSize = 0;
   vec->totSize = 100;
   vec->dataSize = dataSize;
   vec->data = (double**)malloc(sizeof(double*)*vec->totSize);
   
   /* Set all pointers to NULL */
   for (i=0; i<vec->totSize; i++) {
      vec->data[i] = NULL;
   }
   
   return vec;
}


void ne_dyn_vec_free (ne_dyn_vec_t *vec)
{  
   int i;
   
   if (vec != NULL) {
      
      /* Free each of the data items */
      for (i=0; i<vec->totSize; i++) {
         free(vec->data[i]);
      }
      
      /* Free the list of pointers */
      free(vec->data);
      
      /* Free the structure elements */
      free(vec);
   }
}


void ne_dyn_vec_append_item (ne_dyn_vec_t *vec, double *data) 
{  
   int oldSize, newSize, i;
   double** newData = NULL;
   
   /* Check to see if data store is large enough */
   if (vec->totSize <= vec->curSize) {
      
      oldSize = vec->totSize;
      newSize = ne_dyn_vec_extend_fn(oldSize);
      
      /* Need to realloc and copy across data */
      newData = (double**)malloc(sizeof(double*)*newSize);
      
      for (i=0; i<newSize; i++) {
         
         if (i < vec->curSize)
            newData[i] = vec->data[i];
         else
            newData[i] = NULL;
      }
      
      /* Free the old pointer array */
      free(vec->data);
      
      /* Use the newly created array */
      vec->data = newData;
      
      /* Update the size */
      vec->totSize = newSize;
      
      /* Add the new item */
      vec->data[vec->curSize] = data;
      vec->curSize = vec->curSize + 1;
   }
   else {
      
      /* Add the new item */
      vec->data[vec->curSize] = data;
      vec->curSize = vec->curSize + 1;
   }
}


int ne_dyn_vec_extend_fn (int curSize)
{  
   /* Standard approach is to use geometric scaling of vector size */
   return curSize * 2;
}