struct vector *
match_regexp(struct vector *v, char *pattern)
{
struct regexp *reg;
char *res;
int i, num_match;
struct vector *ret;
if (v->size == 0)
return allocate_array(0);
reg = regcomp(pattern, 0);
if (reg == 0)
return 0;
res = (char *)alloca((size_t)v->size);
for (num_match=i=0; i < v->size; i++)
{
res[i] = 0;
if (v->item[i].type != T_STRING)
continue;
eval_cost++;
if (regexec(reg, v->item[i].u.string) == 0)
continue;
res[i] = 1;
num_match++;
}
ret = allocate_array(num_match);
for (num_match=i=0; i < v->size; i++)
{
if (res[i] == 0)
continue;
assign_svalue_no_free(&ret->item[num_match], &v->item[i]);
num_match++;
}
free((char *)reg);
return ret;
}
void f_str_to_arr(){
static struct translation *newt = 0;
if(!newt){
newt = get_translator("UTF-32");
translate_easy(newt->outgoing, " ");
}
int len;
int *trans = (int *)translate(newt->outgoing, sp->u.string, SVALUE_STRLEN(sp)+1, &len);
len/=4;
array_t *arr = allocate_array(len);
while(len--)
arr->item[len].u.number = trans[len];
free_svalue(sp, "str_to_arr");
put_array(arr);
}
/***********************************************************************
* Return one column of a motif, as a newly allocated array of counts.
***********************************************************************/
ARRAY_T* get_motif_counts
(int position,
MOTIF_T* motif)
{
ARRAY_T* return_value = allocate_array(motif->alph_size);
int i_alph;
for (i_alph = 0; i_alph < motif->alph_size; i_alph++) {
set_array_item(i_alph,
motif->num_sites * get_matrix_cell(position,
i_alph, motif->freqs),
return_value);
}
return(return_value);
}
extern MLvalue c2ml_array(int count, ...)
{ mlval arr;
va_list ap;
int i;
arr = allocate_array((size_t)count);
va_start(ap,count);
for (i=0; i < count; i++)
MLUPDATE(arr,i,TO_mlval(va_arg(ap,MLvalue)));
va_end(ap);
return_MLvalue(arr);
}
void
Grid_i::height (CORBA::Short y)
{
if (y > 0 && y != this->height_)
{
GridArray array (allocate_array (this->width_, y));
for (CORBA::Short ctr = 0; ctr < Grid_i::ushort_min (this->height_, y); ++ctr)
{
ACE_OS::memcpy (array.get () + this->width_ * ctr, this->array_.get () + this->width_ * ctr,
this->width_ * sizeof (CORBA::Long));
}
this->array_ = array;
array.release ();
this->height_ = y;
}
}
// Get a value from the grid.
CORBA::Long
Grid_i::get (CORBA::Short x,
CORBA::Short y)
{
if (x < 0
|| y < 0
|| x >= this->width_
|| y >= this->height_)
throw Grid::RANGE_ERROR ();
else
{
if (this->array_.get () == 0)
this->array_.reset (allocate_array (this->width_, this->height_));
return *(this->array_.get () + this->width_ * y + x);
}
}
void
Grid_i::width (CORBA::Short x)
{
if (x > 0 && x != this->width_)
{
GridArray array (allocate_array (x, this->height_));
for (CORBA::Short ctr = 0; ctr < this->height_; ++ctr)
{
ACE_OS::memcpy (array.get () + x * ctr, this->array_.get () + this->width_ * ctr,
Grid_i::ushort_min (this->width_, x) * sizeof (CORBA::Long));
}
this->array_ = array;
array.release ();
this->width_ = x;
}
}
void dxml_handle_background(void *ctx, DREME_ALPH_EN alpha, double A, double C,
double G, double T, DREME_BG_EN source, char *file, char *last_mod_date) {
CTX_T *data;
MOTIF_T *motif;
ARRAY_T *bg;
data = (CTX_T*)ctx;
data->file_type_match = 4; // it must be a dreme xml file!
data->fscope.alphabet = DNA_ALPH;
data->fscope.background = allocate_array(4);
bg = data->fscope.background;
set_array_item(0, A, bg);
set_array_item(1, C, bg);
set_array_item(2, G, bg);
set_array_item(3, T, bg);
}
/*
* Returns a list of all inherited files.
*
*/
struct vector *
inherit_list(struct object *ob)
{
struct vector *ret;
int inh;
ret = allocate_array(ob->prog->num_inherited);
for (inh = 0; inh < (int)ob->prog->num_inherited; inh++ )
{
ret->item[inh].type = T_STRING;
ret->item[inh].string_type = STRING_MSTRING;
ret->item[inh].u.string = add_slash(ob->prog->inherit[inh].prog->name);
}
return ret;
}
/* Runs all elements of an array through fun
and replaces each value in arr by the value returned by fun
*/
struct vector *
map_array (struct vector *arr, struct closure *fun)
{
struct vector *r;
int cnt;
r = allocate_array(arr->size);
push_vector(r, 0);
for (cnt = 0; cnt < arr->size; cnt++) {
push_svalue(&arr->item[cnt]);
(void)call_var(1, fun);
r->item[cnt] = *sp; /* Just copy it. Reference count is correct */
sp--; /* since we loose a reference here. */
}
sp--;
return r;
}
// Set a value in the grid.
void
Grid_i::set (CORBA::Short x,
CORBA::Short y,
CORBA::Long value)
{
if (x < 0
|| y < 0
|| x >= this->width_
|| y >= this->height_)
throw Grid::RANGE_ERROR ();
else
{
if (this->array_.get () == 0)
this->array_.reset (allocate_array (this->width_, this->height_));
*(this->array_.get () + this->width_ * y + x) = value;
}
}
INLINE void bson_to_array P2(const char *, data, svalue_t *, v){
int size;
array_t *av;
svalue_t *sv;
bson_iterator i;
size = sizeof_bson(data);
av = allocate_array(size);
sv = av->item;
bson_iterator_from_buffer( &i, data );
while(bson_iterator_next( &i ) && size--){
bson_to_v(&i,sv);
sv++;
}
v->type = T_ARRAY;
v->u.arr = av;
}
struct svalue *
json_to_array(json_object *ob)
{
int arraylen = json_object_array_length(ob);
static struct svalue ret;
ret.type = T_POINTER;
ret.u.vec = allocate_array(arraylen);
for (int x = 0; x < arraylen; x++)
{
json_object *element = json_object_array_get_idx(ob, x);
assign_svalue_no_free(&ret.u.vec->item[x],
json_to_value(element));
}
return &ret;
}
/**
* @name read_line:
* Read a line portably, relying only upon the C library's
* `getc` standard I/O function. This should work on any
* platform that has a standard I/O (stdio) implementation.
*/
char *read_line(FILE *stream, boolean_t *eof) {
int c;
unsigned int i = 0;
size_t size = read_line_size_start;
char *rv = allocate_array(sizeof(char), size, 1);
for (;;) {
if (!size || i >= size) {
if ((size *= 8) >= read_line_size_maximum) {
goto allocation_error;
}
if (!(rv = reallocate_array(rv, sizeof(char), size, 1))) {
goto allocation_error;
}
}
c = getc(stream);
if (c == '\n') {
break;
} else if (c == EOF) {
*eof = TRUE;
break;
}
rv[i++] = c;
}
rv[i] = '\0';
return rv;
allocation_error:
if (rv) {
free(rv);
}
return NULL;
}
/**
* Tests the pointer array with null values.
*/
void test_pointer_array_with_null_values() {
log_write_terminated_message((void*) stdout, L"Test pointer array with null values:\n");
// The pointer array.
void* a = *NULL_POINTER_MEMORY_MODEL;
int as = *NUMBER_5_INTEGER_MEMORY_MODEL;
allocate_array((void*) &a, (void*) &as, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
/*?? TODO!
overwrite_array(a, (void*) &COMMERCIAL_AT_UNICODE_CHARACTER_CODE_MODEL, (void*) NUMBER_1_INTEGER_MEMORY_MODEL, (void*) NUMBER_0_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
overwrite_array(a, (void*) (void*) &NUMBER_333_INTEGER_MEMORY_MODEL, (void*) NUMBER_1_INTEGER_MEMORY_MODEL, (void*) NUMBER_1_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
overwrite_array(a, (void*) (void*) NULL_POINTER_MEMORY_MODEL, (void*) NUMBER_1_INTEGER_MEMORY_MODEL, (void*) NUMBER_2_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
overwrite_array(a, (void*) (void*) NULL_POINTER_MEMORY_MODEL, (void*) NUMBER_1_INTEGER_MEMORY_MODEL, (void*) NUMBER_3_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
overwrite_array(a, (void*) (void*) &COMMERCIAL_AT_UNICODE_CHARACTER_CODE_MODEL, (void*) NUMBER_1_INTEGER_MEMORY_MODEL, (void*) NUMBER_4_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
*/
// The result values.
char** r0 = (char**) NULL_POINTER_MEMORY_MODEL;
int** r1 = (int**) NULL_POINTER_MEMORY_MODEL;
void** r2 = (void**) NULL_POINTER_MEMORY_MODEL;
void* r3 = *NULL_POINTER_MEMORY_MODEL;
char** r4 = (char**) NULL_POINTER_MEMORY_MODEL;
get_array_elements((void*) &r0, a, (void*) NUMBER_0_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
get_array_elements((void*) &r1, a, (void*) NUMBER_1_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
get_array_elements((void*) &r2, a, (void*) NUMBER_2_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
get_array_elements((void*) &r3, a, (void*) NUMBER_3_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
get_array_elements((void*) &r4, a, (void*) NUMBER_4_INTEGER_MEMORY_MODEL, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
fwprintf(stdout, L"Result pointer as string r0: %s\n", *r0);
fwprintf(stdout, L"Result pointer as integer r1: %i\n", **r1);
fwprintf(stdout, L"Result pointer as pointer r2: %i\n", *r2);
fwprintf(stdout, L"Result pointer as simple pointer r3: %i\n", r3);
fwprintf(stdout, L"Result pointer as character r4: %c\n", **r4);
fwprintf(stdout, L"NULL_POINTER_MEMORY_MODEL: %i \n", NULL_POINTER_MEMORY_MODEL);
fwprintf(stdout, L"*NULL_POINTER_MEMORY_MODEL: %i \n", *NULL_POINTER_MEMORY_MODEL);
deallocate_array((void*) &a, (void*) &as, (void*) POINTER_PRIMITIVE_MEMORY_ABSTRACTION);
}
int main (int argc, char ** argv) {
if (argc != 2) {
fprintf (stderr, "usage: %s <N>\n", argv[0]);
return 1;
}
int N = atoi (argv[1]);
if (N <= 0)
return 1;
int * laminae_counts = allocate_array (TILES + 1, 0);
for (int inner_size = 3;; inner_size++) {
int outer_size = 0;
int squares_used = 0;
for (outer_size = inner_size;; outer_size += 2) {
squares_used += (outer_size - 1) * 4;
if (squares_used > TILES)
break;
laminae_counts[squares_used] += 1;
}
if (inner_size == outer_size)
break;
}
int count = 0;
for (size_t i = 0; i <= TILES; i++)
if (laminae_counts[i] > 0 && laminae_counts[i] <= N)
count++;
printf ("%d\n", count);
free (laminae_counts);
return 0;
}
/* Concatenation of two arrays into one
*/
struct vector *
add_array(struct vector *p, struct vector *r)
{
int cnt,res;
struct vector *d;
d = allocate_array(p->size + r->size);
res = 0;
for (cnt = 0; cnt < p->size; cnt++)
{
assign_svalue_no_free (&d->item[res],&p->item[cnt]);
res++;
}
for (cnt = 0; cnt < r->size; cnt++)
{
assign_svalue_no_free (&d->item[res],&r->item[cnt]);
res++;
}
return d;
}
/**
* Tests the character array with a single element.
*/
void test_character_array_single_element() {
log_write_terminated_message((void*) stdout, L"Test character array single element:\n");
// The character array.
void* c = *NULL_POINTER_MEMORY_MODEL;
int cs = *NUMBER_5_INTEGER_MEMORY_MODEL;
// Create character array.
allocate_array((void*) &c, (void*) &cs, (void*) WIDE_CHARACTER_PRIMITIVE_MEMORY_ABSTRACTION);
/*?? TODO!
overwrite_array(c, (void*) LATIN_CAPITAL_LETTER_A_UNICODE_CHARACTER_CODE_MODEL, (void*) PRIMITIVE_MEMORY_MODEL_COUNT, (void*) NUMBER_0_INTEGER_MEMORY_MODEL, (void*) WIDE_CHARACTER_PRIMITIVE_MEMORY_ABSTRACTION);
overwrite_array(c, (void*) LATIN_CAPITAL_LETTER_B_UNICODE_CHARACTER_CODE_MODEL, (void*) PRIMITIVE_MEMORY_MODEL_COUNT, (void*) NUMBER_1_INTEGER_MEMORY_MODEL, (void*) WIDE_CHARACTER_PRIMITIVE_MEMORY_ABSTRACTION);
overwrite_array(c, (void*) LATIN_CAPITAL_LETTER_C_UNICODE_CHARACTER_CODE_MODEL, (void*) PRIMITIVE_MEMORY_MODEL_COUNT, (void*) NUMBER_2_INTEGER_MEMORY_MODEL, (void*) WIDE_CHARACTER_PRIMITIVE_MEMORY_ABSTRACTION);
overwrite_array(c, (void*) LINE_FEED_CONTROL_UNICODE_CHARACTER_CODE_MODEL, (void*) PRIMITIVE_MEMORY_MODEL_COUNT, (void*) NUMBER_3_INTEGER_MEMORY_MODEL, (void*) WIDE_CHARACTER_PRIMITIVE_MEMORY_ABSTRACTION);
overwrite_array(c, (void*) NULL_CONTROL_UNICODE_CHARACTER_CODE_MODEL, (void*) PRIMITIVE_MEMORY_MODEL_COUNT, (void*) NUMBER_4_INTEGER_MEMORY_MODEL, (void*) WIDE_CHARACTER_PRIMITIVE_MEMORY_ABSTRACTION);
*/
// Print out array contents.
log_write_terminated_message((void*) stdout, (wchar_t*) c);
int i = *NUMBER_0_INTEGER_MEMORY_MODEL;
wchar_t* catest = (wchar_t*) *NULL_POINTER_MEMORY_MODEL;
while (*TRUE_BOOLEAN_MEMORY_MODEL) {
if (i >= cs) {
break;
}
catest = (wchar_t*) (c + i);
fwprintf(stdout, L"ca: %c\n", *catest);
i++;
}
// Destroy character array.
deallocate_array((void*) &c, (void*) &cs, (void*) WIDE_CHARACTER_PRIMITIVE_MEMORY_ABSTRACTION);
}
/***********************************************************************
* Create a bootstrapped copy of the given array.
*
* Allocates the bootstrap array; must be freed by caller.
* Assumes that the random number generator is initialized.
***********************************************************************/
ARRAY_T* bootstrap_array
(ARRAY_T* source_array,
int num_items)
{
ARRAY_T* return_array;
check_null_array(source_array);
// Allocate the bootstrap array.
return_array = allocate_array(num_items);
// Fill up the bootstrap array.
int i_item;
int num_inputs = get_array_length(source_array);
for (i_item = 0; i_item < num_items; i_item++) {
int random_index = (int)(my_drand() * (double)(num_inputs));
ATYPE random_item = get_array_item(random_index, source_array);
set_array_item(i_item, random_item, return_array);
}
return(return_array);
}
static vector_t *
fetch_into_vector( hDBC * handle )
{
int i;
vector_t * vec;
STORE_DOUBLE_USED;
vec = allocate_array( handle->colcnt );
MEM_CHECK( vec );
for( i = 0; i < handle->colcnt; ++i ) {
if ( !handle->columns[ i ] ) continue;
//printf( " fetch_into_vector[%2d] ", i );
switch( handle->columns[ i ]->type ){
case T_FLOAT:
//printf( "float=%f\n", handle->columns[ i ]->data.double_v );
STORE_DOUBLE( vec->item + i, *handle->columns[ i ]->data.double_v );
( vec->item + i)->type = T_FLOAT;
break;
case T_NUMBER:
//printf( "number=%d\n", *handle->columns[ i ]->data.number_v );
put_number( vec->item + i, *handle->columns[ i ]->data.number_v );
break;
case T_STRING:
default :
//printf( "string=%s\n", handle->columns[ i ]->data.string_v );
put_malloced_string( vec->item + i, string_copy( handle->columns[ i ]->data.string_v ) );
break;
}
}
return( vec );
}
/*************************************************************************
* Build array containing the counts of columns in the alignment
* Caller is responsible for freeing the returned array.
* If input parameter "freqs" is NULL, allocates the array.
* Otherwise, the counts are added to the existing counts in the counts
* array. Ignores all columns containing gaps or ambiguity characters:
* [.-nNxX]
*************************************************************************/
static ARRAY_T* build_alignment_column_counts(
ALPH_T alph,
ALIGNMENT_T* alignment,
ARRAY_T* counts
)
{
assert(alignment != NULL);
int asize = alph_size(alph, ALPH_SIZE);
// Calculate number of possible alignment columns
// and create storage for counting occurences.
int num_seqs = get_num_aligned_sequences(alignment);
int num_alignment_cols = (int) pow((double) asize, (double) num_seqs);
if (counts == NULL) {
counts = allocate_array(num_alignment_cols);
}
// Count how many examples of each column occur in the alignment.
// Skip columns that contain gaps or ambiguity characters.
int alignment_length = get_alignment_length(alignment);
char* alignment_col = mm_malloc(sizeof(char) * (num_seqs + 1));
alignment_col[num_seqs] = 0;
int i, h;
for(i = 0; i < alignment_length; i++) {
get_alignment_col(i, alignment_col, alignment);
if (strchr(alignment_col, '-') != NULL) { continue; }
if (strchr(alignment_col, '.') != NULL) { continue; }
if (strchr(alignment_col, 'N') != NULL) { continue; }
if (strchr(alignment_col, 'n') != NULL) { continue; }
if (strchr(alignment_col, 'X') != NULL) { continue; }
if (strchr(alignment_col, 'x') != NULL) { continue; }
h = hash_alignment_col(alph, alignment_col, num_seqs);
incr_array_item(h, 1, counts);
}
return counts;
} // build_alignment_column_counts
/****************************************************************************
* Return an array containing the frequencies in the alignment for each
* character of the alphabet. Gaps and ambiguity characters other then
* ANY_BASE are not counted. The freq. of ANY_BASE characters is stored
* in the last element of the array.
****************************************************************************/
ARRAY_T* get_alignment_freqs(ALPH_T alph, ALIGNMENT_T* alignment) {
char c = 0;
int aindex = 0;
int asize = 0;
int i = 0;
int s = 0;
int total_bases = 0;
int* num_bases = NULL;
ARRAY_T* freqs = NULL;
// Initialize counts for each character in the alphabet
asize = alph_size(alph, ALPH_SIZE);
num_bases = mm_malloc(asize * sizeof(int));
for (i = 0; i < asize; i++) {
num_bases[i] = 0;
}
for (s = 0; s < alignment->num_sequences; s++) {
for (i = 0; i < alignment->length; i++) {
c = get_seq_char(i, alignment->sequences[s]);
aindex = alph_index(alph, c);
// c might be an ambiguity code. We don't count ambiguity codes.
if (aindex != -1 && aindex < asize) {
num_bases[aindex]++;
total_bases++;
}
}
}
freqs = allocate_array(asize);
for (i = 0; i < asize; i++) {
set_array_item(i, (double) num_bases[i] / (double) total_bases, freqs);
}
// Clean up the count of characters
myfree(num_bases);
return freqs;
}
/***************************************************************************
* Set the sequence weights according to an external file.
*
* If the filename is "none," "internal," or NULL, then the weights are
* set uniformly.
***************************************************************************/
void set_sequence_weights
(char* weight_filename, // Name of file containing sequence weights.
int num_seqs, // Number of sequences.
SEQ_T** sequences) // The sequences.
{
ARRAY_T* weights;
FILE * weight_file;
int i_seq;
/* Allocate the weights. */
weights = allocate_array(num_seqs);
/* Set uniform weights if no file was supplied. */
if ((weight_filename == NULL) || (strcmp(weight_filename, "none") == 0) ||
(strcmp(weight_filename, "internal") == 0)) {
init_array(1.0, weights);
}
/* Read the weights from a file. */
else {
if (open_file(weight_filename, "r", FALSE, "weight", "weights",
&weight_file) == 0)
exit(1);
read_array(weight_file, weights);
fclose(weight_file);
/* Normalize the weights so they add to the total number of sequences. */
normalize(0.0, weights);
scalar_mult(num_seqs, weights);
}
/* Assign the weights to the sequences. */
for (i_seq = 0; i_seq < num_seqs; i_seq++) {
(sequences[i_seq])->weight = get_array_item(i_seq, weights);
}
/* Free the weights. */
free_array(weights);
}
/*****************************************************************************
* MEME > model > background_frequencies > alphabet_array > value
****************************************************************************/
void mxml_background_value(void *ctx, char *id, double freq) {
CTX_T *data;
char *symbol;
int index;
data = (CTX_T*)ctx;
symbol = (char*)rbtree_get(data->letter_lookup, id);
if (symbol == NULL) {
local_error(data, "Background for unknown letter identifier \"%s\".\n", id);
return;
}
index = alph_indexc(data->alph, symbol[0]);
if (index < 0) {
local_error(data, "Background for non-core letter %c.\n", symbol[0]);
return;
}
if (data->nums == NULL) {
data->nums = allocate_array(alph_size_core(data->alph));
init_array(-1, data->nums);
}
set_array_item(index, freq, data->nums);
}
int *calc_breakpoints(int n, int threads)
{
int i, *v; /* v is pointer to the vector */
int rows = n/threads;
int remainder = n%threads; /* number of rows not evenly distributed */
int last_k = threads - remainder; /* number of threads get extra row */
v = allocate_array(threads+1);
/* row bands are attempted to be distributed evenly */
for(i = 1; i <= threads; i++)
v[i] += (v[i-1] + rows);
/* The number of remaining rows are spread as evenly as possible amongst
* the generated threads. This is done by giving the last k threads and
* extra row, where k = remainder.
*/
for(i = threads; i > last_k; i--)
v[i] += remainder--;
return(v); /* returns pointer to the vector */
} /* end calculate breakpoints */
void LIRGenerator::do_NewTypeArray(NewTypeArray* x) {
LIRItem length(x->length(), this);
length.load_item();
LIR_Opr reg = result_register_for(x->type());
LIR_Opr tmp1 = FrameMap::G1_oop_opr;
LIR_Opr tmp2 = FrameMap::G3_oop_opr;
LIR_Opr tmp3 = FrameMap::G4_oop_opr;
LIR_Opr tmp4 = FrameMap::O1_oop_opr;
LIR_Opr klass_reg = FrameMap::G5_oop_opr;
LIR_Opr len = length.result();
BasicType elem_type = x->elt_type();
__ oop2reg(ciTypeArrayKlass::make(elem_type)->encoding(), klass_reg);
CodeEmitInfo* info = state_for(x, x->state());
CodeStub* slow_path = new NewTypeArrayStub(klass_reg, len, reg, info);
__ allocate_array(reg, len, tmp1, tmp2, tmp3, tmp4, elem_type, klass_reg, slow_path);
LIR_Opr result = rlock_result(x);
__ move(reg, result);
}
struct Buf *
buf_append(struct Buf *buf, const void *ptr, int n_elem)
{
int n_alloc = 0;
if (!ptr || n_elem == 0)
return buf;
/* May need to alloc more. */
if (n_elem + buf->nelts > buf->nmax) {
/* exact amount needed... */
n_alloc = (n_elem + buf->nelts) * buf->elt_size;
/* ...plus some extra */
if (((n_alloc * buf->elt_size) % 512) != 0
&& buf->elt_size < 512)
n_alloc +=
(512 -
((n_alloc * buf->elt_size) % 512)) /
buf->elt_size;
if (!buf->elts)
buf->elts =
allocate_array(n_alloc, buf->elt_size);
else
buf->elts =
reallocate_array(buf->elts, n_alloc,
buf->elt_size);
buf->nmax = n_alloc;
}
memcpy((char *) buf->elts + buf->nelts * buf->elt_size, ptr,
n_elem * buf->elt_size);
buf->nelts += n_elem;
return buf;
}
/****************************************************************************
* Return an array containing the frequencies in the sequence for each
* character of the alphabet. Characters not in the alphabet are not
* counted.
****************************************************************************/
ARRAY_T* get_sequence_freqs
(SEQ_T* seq, ALPH_T alph)
{
char c = 0;
int a_index = 0;
int a_size = 0;
int i = 0;
int total_bases = 0;
int* num_bases = NULL;
ARRAY_T* freqs = NULL;
// Initialize counts for each character in the alphabet
a_size = alph_size(alph, ALPH_SIZE);
num_bases = mm_malloc(a_size * sizeof(int));
for (i = 0; i < a_size; i++) {
num_bases[i] = 0;
}
for (i = 0; i < seq->length; i++) {
c = get_seq_char(i, seq);
if (c != '-' && c != '-') {
a_index = alph_index(alph, c);
if (a_index == -1 || a_index >= a_size) continue;
num_bases[a_index]++;
total_bases++;
}
}
freqs = allocate_array(a_size);
for (i = 0; i < a_size; i++) {
set_array_item(i, (double) num_bases[i] / (double) total_bases, freqs);
}
// Clean up the count of characters
myfree(num_bases);
return freqs;
}
static struct vector *
make_cpu_array2(int i, struct program *prog[])
{
int num;
struct vector *ret;
char buff[1024]; /* should REALLY be enough */
if (i <= 0)
return 0;
ret = allocate_array(i);
for(num = 0; num < i; num++)
{
(void)sprintf(buff, "%22.18g:%s",
(double)(prog ? prog[num]->cpu_avg * 1e6: 0L),
prog ? prog[num]->name : "");
free_svalue(&ret->item[num]);
ret->item[num].type = T_STRING;
ret->item[num].string_type = STRING_MSTRING;
ret->item[num].u.string = make_mstring(buff);
}
return ret;
}
double *create_external_input(double scale, double dt)
{
double min = 10e10, max = -10e010, ave = 0.0, *data;
int i, sz;
/* How many neurons? */
sz = sizeof(task_assigment_scores) / sizeof(double);
/* Get some memory. */
data = allocate_array(1, sizeof(double), sz);
for(i = 0; i < sz; i++) {
if(task_assigment_scores[i] < min) min = task_assigment_scores[i];
if(task_assigment_scores[i] > max) max = task_assigment_scores[i];
ave += task_assigment_scores[i];
}
ave /= sz;
for(i = 0; i < sz; i++)
data[i] = dt * (scale * (task_assigment_scores[i] - ave) /
(max - min) + 2);
return(data);
}
