allocation

I need to calculate entries of a vector whose length I do not know beforehand . How to do so efficiently? A trivial solution is to "grow" it: start with a small or empty vector and successively append new entries until the stopping criterion is reached. For example: foo <- numeric(0) while ( sum(foo) < 100 ) foo <- c(foo,runif(1)) length(foo) # 195 However, "growing" vectors is frowned upon in R for performance reasons. Of course, I could "grow it in chunks": pre-allocate a "good-sized" vector, fill it, double its length when it is full, and finally cut it down to size. But this feels error

I want to dynamically allocate a C struct: typedef struct { short *offset; char *values; } swc; Both 'offset' and 'values' are supposed to be arrays, but their size is unknown until runtime. How can I dynamically allocate memory for my struct and the struct's arrays? swc *a = (swc*)malloc(sizeof(swc)); a->offset = (short*)malloc(sizeof(short)*n); a->values = (char*)malloc(sizeof(char)*n); Where n = the number of items in each array and a is the address of the newly allocated data structure. Don't forget to free() offsets and values before free()'ing a. In C: swc *s = malloc(sizeof *s); //

I'm porting a game to Android (there's a lot of code and very little of it is mine), and DalvikVM is telling me (through LogCat) all about the garbage collection. At some point in the code, I get a stream of "GC freed x objects / x ms" messages, basically informing me that ~150,000 objects have just been deleted and it's taking a full second. I want to know where these came from! I am pretty sure I'm not creating that many objects intentionally. So, is there a way to get... basically the opposite of that message? Something that prints a log message when any object is created ? That way I could

I'm reading through Mark Dalrymple's Learn Objective-C on the Mac (only at the chapter on Protocols, so still relatively newbish) and trying to figure something out: Why would you ever reference a class by its own name? If I had a class called Foo , why would I ever want to write, say, [[Foo alloc] init] and not [[[self class] alloc] init] If I had a subclass Bar, wouldn't the first option invalidate me from writing [[Bar alloc] init] whereas the second option would allow it? When would the first option be better? Generally, within a class method, you do use [[self alloc] init] . For example,

I was testing the speeds of a few different ways to do complex iterations over some of my data, and I found something weird. It seems that having a large list local to some function slows down that function considerably, even if it is not touching that list. For example, creating 2 independent lists via 2 instances of the same generator function is about 2.5x slower the second time. If the first list is removed prior to creating the second, both iterators go at the same spee. def f(): l1, l2 = [], [] for c1, c2 in generatorFxn(): l1.append((c1, c2)) # destroying l1 here fixes the problem for

I am trying to write a HDF5 file with a structure which contains an int and a float* typedef struct s1_t { int a; float *b; } s1_t; However, upon allocating the float* and putting values into it, I still can't output the data in my hdf5 file. I believe this is because the write function assumes that the compound data type is contiguous when a dynamically allocated array will not be. Is there any way around this problem by still using a pointer array? /* * This example shows how to create a compound data type with an array member, * and write an array which has the compound data type to the