double * rk4a_interpolate(double *zt_seq, int dim, int freq)
{
double T, *tmp2, *zt_out;
int n = 0, m=0, j=0, N = 1000;
zt_out = (double *) calloc((dim+1) * N, sizeof(double));
if(zt_out == NULL) alloc_fail();
T = 1./freq;
do
{
n++;
if(zt_seq[n * (dim+1) + dim] > ((double)m)*T)
{
for(j=0;j<dim;j++)
zt_out[m * (dim+1) + j] = zt_seq[n * (dim+1) + j];
zt_out[m * (dim+1) + dim] = ((double)m)*T;
m++;
if(m>N-2)
{
N+=1000;
tmp2 = (double*) realloc(zt_out, (dim+1)*N* sizeof(double));
if (tmp2 != NULL) zt_out=tmp2;
else alloc_fail();
}
}
} while(zt_seq[n * (dim +1) + dim] != 0);
zt_out = (double*) realloc(zt_out, (dim+1)*(m+2)* sizeof(double));
return zt_out;
}
static void remove_node(void *p)
{
malloc_node *m, *n;
if (!p) return; /* deallocating NULL is fine */
n = nodes;
if (!n) {
if (paranoia == 1) return;
fprintf(stderr, "Deallocating %p when nothing allocated\n", p);
if (paranoia == 2) return;
alloc_fail();
}
if (n->p == p) {
nodes = n->next;
free(n);
return;
}
for (m = n->next; m; m = m->next) {
if (m->p == p) {
n->next = m->next;
free(m);
return;
}
n = m;
}
if (paranoia == 1) return;
fprintf(stderr, "Deallocating %p which was not allocated\n", p);
if (paranoia == 2) return;
alloc_fail();
}
// invertieren
struct mat matrix_invertieren(struct mat matrix_in)
{
// An die zu invertierende Matrix (muss quadratisch und linear unabhängig sein) wird die Einheitsmatrix drangehängt. Die große Matrix wird danach auf Diagonalform gebracht. Die ehemalige einheitsmatrix wird wieder abgeschnitten. Fertig ist die invertierte.
int i, j;
double det;
struct mat einheit;
einheit=matrix_e(matrix_in.zeilen);
struct mat tmp, matrix_out, tmp2;
tmp2.spalten = matrix_in.spalten;
tmp2.zeilen = matrix_in.zeilen;
tmp2.matrix = (double *) calloc(tmp2.zeilen * tmp2.spalten, sizeof(double));
if(tmp2.matrix == NULL) alloc_fail();
for(i=0;i<tmp2.zeilen;i++)
for(j=0;j<tmp2.spalten;j++)
tmp2.matrix[i* tmp2.spalten+j] = matrix_in.matrix[i* matrix_in.spalten+j];
det = matrix_det(tmp2);
//~ if(det < -FLOATNULL || det > FLOATNULL) // Wenn Determinante != 0
if(det != 0) // Wenn Determinante != 0
{
tmp.spalten = matrix_in.spalten*2;
tmp.zeilen = matrix_in.zeilen;
tmp.matrix = (double *) calloc(tmp.zeilen * tmp.spalten, sizeof(double));
if(tmp.matrix == NULL) alloc_fail();
matrix_out.spalten = matrix_in.spalten;
matrix_out.zeilen = matrix_in.zeilen;
matrix_out.matrix = (double *) calloc(matrix_out.zeilen * matrix_out.spalten, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
for(i=0;i<matrix_in.zeilen;i++)
for(j=0;j<matrix_in.spalten;j++)
tmp.matrix[i* tmp.spalten+j] = matrix_in.matrix[i* matrix_in.spalten+j];
for(i=0;i<matrix_in.zeilen;i++)
for(j=0;j<matrix_in.spalten;j++)
tmp.matrix[i* tmp.spalten+j+matrix_in.spalten] = einheit.matrix[i* einheit.spalten+j];
tmp = matrix_dgf(tmp);;
for(i=0;i<matrix_in.zeilen;i++)
for(j=0;j<matrix_in.spalten;j++)
matrix_out.matrix[i* matrix_in.spalten +j] = tmp.matrix[i* tmp.spalten + (j+matrix_in.spalten)];
free(matrix_in.matrix);
free(tmp.matrix);
return matrix_out;
}
else
{
printf("Die Matrix ist nicht invertierbar.\n");
matrix_out.zeilen = matrix_out.spalten = 0;
matrix_out.matrix = NULL;
return matrix_out;
}
}
struct mat matrix_auslesen(struct mat matrix_in, char *filename)
{
int i,j;
FILE *datei;
struct mat matrix_out;
printf("Matrix wird aus %s gelesen!\n", filename);
datei = fopen (filename, "r");
if (datei == NULL)
{
printf("Fehler beim Öffnen der Datei!\n");
matrix_out.zeilen = matrix_out.spalten = 0;
return matrix_out;
}
fscanf(datei, "%dx%d", &matrix_out.zeilen, &matrix_out.spalten);
matrix_out.matrix = (double *) calloc(matrix_out.zeilen * matrix_out.spalten, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
for(i=0;i<matrix_out.zeilen;i++)
for(j=0;j<matrix_out.spalten;j++)
fscanf(datei, "%lf", &matrix_out.matrix[j* matrix_out.zeilen+i]);
fclose (datei);
return (matrix_out);
}
// Zeile/Spalte streichen
struct mat matrix_streichen(struct mat matrix_in, int i, int j)
{
int p, q, n, m;
struct mat tmp;
tmp.spalten = matrix_in.spalten - 1;
tmp.zeilen = matrix_in.zeilen - 1;
tmp.matrix = (double *) calloc(tmp.zeilen * tmp.spalten, sizeof(double));
if(tmp.matrix == NULL) alloc_fail();
for(m=0,q=0;q<matrix_in.zeilen;q++,m++)
{
if(q==j)
{
m--;
continue;
}
for(n=0,p=0;p<matrix_in.spalten;p++,n++)
{
if(p==i)
{
n--;
continue;
}
tmp.matrix[m* tmp.spalten+n] = matrix_in.matrix[q* matrix_in.spalten+p];
}
}
return(tmp);
}
// Adjunkte Matrix finden
struct mat matrix_adjunkte(struct mat matrix_in)
{
int i, j;
double det=0;
struct mat matrix_out;
matrix_out.spalten = matrix_in.spalten;
matrix_out.zeilen = matrix_in.zeilen;
matrix_out.matrix = (double *) calloc(matrix_out.zeilen * matrix_out.spalten, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
if(matrix_out.zeilen != matrix_out.spalten)
{
matrix_out.zeilen = matrix_out.spalten = 0;
return matrix_out;
}
for(i=0;i<matrix_in.zeilen;i++)
for(j=0;j<matrix_in.spalten;j++)
{
det = matrix_det(matrix_streichen(matrix_in,i,j));
if(i%2==1)
det*=-1;
if(j%2==1)
det*=-1;
matrix_out.matrix[i* matrix_in.spalten+j]=det;
}
return matrix_out;
}
// Erzeugt eine n x m zufallsmatrix
// p=1: nur positive Werte, g obere Grenze des Betrags der Werte,
// z=1 nur ganze Zahlen
struct mat matrix_rand(int n, int m, int p, int z, int g)
{
int i, j;
int vz=1;
struct mat matrix_out;
matrix_out.zeilen = n;
matrix_out.spalten = m;
matrix_out.matrix = (double *) calloc(n * m, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
for(i=0;i<matrix_out.zeilen;i++)
for(j=0;j<matrix_out.spalten;j++)
{
if(!p)
{
vz = rand()%2;
if(vz == 0)
vz = -1;
}
if(z)
matrix_out.matrix[j* matrix_out.zeilen+i] = (rand() % (g+1)) * vz;
else
matrix_out.matrix[j* matrix_out.zeilen+i] = ((double)rand() / RAND_MAX ) * g * vz;
}
return matrix_out;
}
struct mat matrix_matrixprodukt(struct mat matrix1, struct mat matrix2)
{
int i, j, k;
struct mat matrix_out;
if(matrix1.spalten != matrix2.zeilen)
{
printf("Die Dimension der Spalten der ersten Matrix stimmt nicht mit der Dimension der Zeilen der zweiten Matrix überein.\n");
matrix_out.zeilen = matrix_out.spalten = 0;
matrix_out.matrix = NULL;
return matrix_out;
}
matrix_out.zeilen = matrix1.zeilen;
matrix_out.spalten = matrix2.spalten;
matrix_out.matrix = (double *) calloc(matrix_out.zeilen * matrix_out.spalten, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
for(i=0;i<matrix_out.zeilen;i++)
for(j=0;j<matrix_out.spalten;j++)
for(k=0;k<matrix1.spalten;k++)
matrix_out.matrix[i*matrix_out.spalten+j] += matrix2.matrix[k*matrix2.spalten+j]*matrix1.matrix[i*matrix1.spalten+k];
free(matrix1.matrix);
free(matrix2.matrix);
return matrix_out;
}
void dx_shift_stringid(Dex* dx, uint32_t base, int32_t delta) {
unsigned int i;
dx_shift *shift, *prev;
if (dx == NULL) return;
shift = (dx_shift*) malloc(sizeof(dx_shift));
if (shift == NULL) alloc_fail();
shift->base = base;
shift->delta = delta;
shift->next = NULL;
for (i=0; i<dx->header->type_ids_size; i++)
dxsi_typeid(dx->type_ids[i],shift);
for (i=0; i<dx->header->proto_ids_size; i++)
dxsi_protoid(dx->proto_ids[i],shift);
for (i=0; i<dx->header->field_ids_size; i++)
dxsi_fieldid(dx->field_ids[i],shift);
for (i=0; i<dx->header->method_ids_size; i++)
dxsi_methodid(dx->method_ids[i],shift);
for (i=0; i<dx->header->class_defs_size; i++)
dxsi_classdef(dx->class_defs[i],shift);
for (i=0; i<dx->meta.encoded_arrays_size; i++)
dxsi_encodedarray(dx->encoded_arrays[i],shift);
for (i=0; i<dx->meta.debug_info_list_size; i++)
dxsi_debuginfo(dx->debug_info_list[i],shift);
for (i=0; i<dx->meta.annotations_size; i++)
dxsi_annotationitem(dx->annotations[i],shift);
prev = shift;
shift = shift->next;
free(prev);
//ULEB expansion
while (shift != NULL) {
printf("delta2 = %d\n",shift->delta);
dx->header->file_size += shift->delta;
if (shift->base > dx->header->data_off)
dx->header->data_size += shift->delta;
dx_shift_offset(dx,shift->base,shift->delta);
prev = shift;
shift = shift->next;
free(prev);
}
}
void *MwCalloc(size_t nmemb, size_t size)
{
void *p;
p = calloc(nmemb, size);
if (p == NULL) alloc_fail();
if (paranoia) insert_node(p);
return p;
}
void *MwRealloc(void *ptr, size_t size)
{
void *p;
if (paranoia) remove_node(ptr);
p = realloc(ptr, size);
if (p == NULL) alloc_fail();
if (paranoia) insert_node(p);
return p;
}
char *MwStrdup(const char *s)
{
char *p;
if (s) p = malloc(strlen(s)+1);
else p = NULL;
if (p == NULL) alloc_fail();
else strcpy(p, s);
if (paranoia) insert_node(p);
return p;
}
static void insert_node(void *p)
{
malloc_node *n;
if (!p) return; /* we don't need to remember NULL */
n = malloc(sizeof(malloc_node));
if (n == NULL) alloc_fail();
n->p = p;
n->next = nodes;
nodes = n;
}
void *MwMalloc(size_t size)
{
void *p;
p = malloc(size);
if (p == NULL) alloc_fail();
if (paranoia) insert_node(p);
/* Courtesy of Youki Kadobayashi <*****@*****.**> */
memset(p, 1, size);
return p;
}
obj_t * apply(obj_t *args, obj_t *env) {
assert(IS_LIST(args));
if (IS_LIST(CAR(args)) && IS_FUNC(CAR(CAR(args)))) {
return (FUNC(CAR(CAR(args))))(CDR(args), env);
} else if (IS_LIST(CAR(args)) && IS_DEFUNC(CAR(CAR(args)))) {
obj_t * func_args;
obj_t * call_args;
obj_t * body;
obj_t * result;
body = clone_obj(BODY(CAR(CAR(args))));
func_args = ARGS(CAR(CAR(args)));
call_args = CDR(args);
/* ((<DEFUNC:[args=(X)][body=(TIMES X X)]>) 3) */
while (IS_LIST(func_args) && IS_LIST(call_args)) {
obj_t * func_arg = CAR(func_args);
obj_t * call_arg = CAR(call_args);
replace_obj(func_arg, call_arg, body);
func_args = CDR(func_args);
call_args = CDR(call_args);
}
if ((IS_LIST(func_args) && !IS_LIST(call_args)) ||
(!IS_LIST(func_args) && IS_LIST(call_args))) {
free_obj(body); /* clean up */
fprintf(stdout, "Unexpected number of arguments\n");
return alloc_fail();
}
result = eval(body, env);
free_obj(body);
return result;
} else {
return clone_obj(args);
}
}
void MwMallocExit(void)
{
malloc_node *n;
if (paranoia == 0) return;
for (n = nodes; n; n = n->next) {
if (paranoia >= 2) {
fprintf(stderr, "Didn't deallocate %p\n", n->p);
return;
}
if (paranoia == 3) alloc_fail();
}
}
struct mat matrix_transponieren(struct mat matrix_in)
{
int i, j;
struct mat matrix_out;
matrix_out.zeilen = matrix_in.spalten;
matrix_out.spalten = matrix_in.zeilen;
matrix_out.matrix = (double *) calloc(matrix_out.zeilen * matrix_out.spalten, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
for(i=0;i<matrix_in.zeilen;i++)
for(j=0;j<matrix_in.spalten;j++)
matrix_out.matrix[j* matrix_out.spalten+i] = matrix_in.matrix[i* matrix_in.spalten+j];
free(matrix_in.matrix);
return matrix_out;
}
struct mat matrix_addieren(struct mat matrix1, struct mat matrix2)
{
int i, j;
struct mat matrix_out;
matrix_out.zeilen = matrix1.zeilen;
matrix_out.spalten = matrix1.spalten;
matrix_out.matrix = (double *) calloc(matrix_out.zeilen * matrix_out.spalten, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
for(i=0;i<matrix_out.zeilen;i++)
for(j=0;j<matrix_out.spalten;j++)
matrix_out.matrix[i* matrix_out.spalten+j] = matrix1.matrix[i* matrix1.spalten+j]+matrix2.matrix[i* matrix2.spalten+j];
free(matrix1.matrix);
free(matrix2.matrix);
return matrix_out;
}
// Erzeugt eine n x n Einheitsmatrix
struct mat matrix_e(int n)
{
int i, j;
struct mat matrix_out;
matrix_out.zeilen = matrix_out.spalten = n;
matrix_out.matrix = (double *) calloc(n * n, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
for(i=0;i<matrix_out.zeilen;i++)
for(j=0;j<matrix_out.spalten;j++)
{
if(i==j)
matrix_out.matrix[j* matrix_out.zeilen+i] = 1;
else
matrix_out.matrix[j* matrix_out.zeilen+i] = 0;
}
return matrix_out;
}
// invertieren mit Adjunkter
struct mat matrix_invertieren_adjunkte(struct mat matrix_in)
{
double det;
struct mat tmp;
tmp.spalten = matrix_in.spalten;
tmp.zeilen = matrix_in.zeilen;
tmp.matrix = (double *) calloc(tmp.zeilen * tmp.spalten, sizeof(double));
if(tmp.matrix == NULL) alloc_fail();
tmp=matrix_adjunkte(matrix_in);
det=matrix_det(matrix_in);
if(det > -FLOATNULL && det < FLOATNULL) // Wenn Determinante == 0
{
tmp.zeilen = tmp.spalten = 0;
return tmp;
}
det=1/det;
return(matrix_skalaprodukt(tmp,det));
}
//Vertauschen der k-ten und l-ten Zeile
struct mat matrix_z_P(struct mat matrix_in, int k, int l)
{
int i, j;
struct mat matrix_out;
matrix_out.zeilen = matrix_in.zeilen;
matrix_out.spalten = matrix_in.spalten;
matrix_out.matrix = (double *) calloc(matrix_out.zeilen * matrix_out.spalten, sizeof(double));
if(matrix_out.matrix == NULL) alloc_fail();
for(i=0;i<matrix_out.zeilen;i++)
for(j=0;j<matrix_out.spalten;j++)
matrix_out.matrix[i* matrix_out.spalten+j] = matrix_in.matrix[i* matrix_in.spalten+j];
for(j=0;j<matrix_in.spalten;j++)
{
matrix_out.matrix[k* matrix_out.spalten+j] = matrix_in.matrix[l* matrix_in.spalten+j];
matrix_out.matrix[l* matrix_out.spalten+j] = matrix_in.matrix[k* matrix_in.spalten+j];
}
//~ free(matrix_in.matrix);
return matrix_out;
}
