name string | code string | asm string | file string |
|---|---|---|---|
ywalg2 | void ywalg2(double *x, int N, int p, double *phi,double *var) {
int lag, k, j;
double *acf, *z, *y, *temp1, *temp2;
double a, b;
// Same as ywalg except it also returns the variance value
lag = p + 1;
acf = (double*)malloc(sizeof(double)* lag);
y = (double*)malloc(sizeof(double)* lag);
z = (double*)malloc(sizeo... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, -0x80(%rbp)
movq %rcx, -0x78(%rbp)
movl %edx, %ebx
movl %esi, -0x30(%rbp)
movq %rdi, -0x50(%rbp)
leal 0x1(%rbx), %eax
movl %eax, -0x40(%rbp)
cltq
movq %rax, -0x70(%rbp)
leaq (,%rax,8), %r14
movq %r14, %rdi
callq... | /rafat[P]ctsa/src/initest.c |
hralg | void hralg(double *x, int N, int p,int q, double *phi,double *theta, double *var) {
int m,i,t,pq,j,k;
double wmean,sos;
double *inp,*phim,*a,*z,*zt,*A,*b,*temp;
int *ipiv;
inp = (double*)malloc(sizeof(double)* N);
if (p > q) {
m = p;
}
else {
m = q;
}
if (m < 10 && N > p+q+20) {
m = 10;
}
else {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, -0xb0(%rbp)
movq %r8, -0xa8(%rbp)
movl %ecx, %ebx
movl %edx, %r14d
movq %rdi, -0x40(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl %esi, -0x34(%rbp)
movslq %esi, %rax
leaq (,%rax,8), %r15
movq %rax, %r1... | /rafat[P]ctsa/src/initest.c |
hrstep2 | void hrstep2(double *inp, int N, int m, int p, int q, int pq, double *a, double *sos, double *var) {
double *z, *zt, *A, *b, *temp;
int *ipiv;
int i,j,k,t;
double wmean;
z = (double*)malloc(sizeof(double)* (N - m - q) * pq);
zt = (double*)malloc(sizeof(double)* (N - m - q) * pq);
A = (double*)malloc(sizeof(doub... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, -0x68(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdi, %r15
movq 0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
leal (%r8,%rdx), %ecx
movl %esi, -0x70(%rbp)
mo... | /rafat[P]ctsa/src/initest.c |
pacf_burg | void pacf_burg(double* vec, int N, double* par, int M) {
int i;
double *temp;
double var;
temp = (double*)malloc(sizeof(double)* M);
for (i = 0; i < M; ++i) {
burgalg(vec, N-1, i + 1, temp, &var);
par[i] = temp[i];
}
free(temp);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, -0x38(%rbp)
movl %esi, %r14d
movq %rdi, -0x30(%rbp)
movslq %ecx, %rbx
leaq (,%rbx,8), %rdi
callq 0x6190
movq %rax, %r12
testl %ebx, %ebx
jle 0x1a95e
decl %r14d
movl %r13d, %ebx
xorl %r13d, %r13... | /rafat[P]ctsa/src/initest.c |
pacf_yw | void pacf_yw(double* vec, int N, double* par, int M) {
int i;
double *temp;
temp = (double*)malloc(sizeof(double)* M);
for (i = 0; i < M; ++i) {
ywalg(vec, N, i + 1, temp);
par[i] = temp[i];
}
free(temp);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, -0x38(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdi, %r15
movslq %ecx, %rbx
leaq (,%rbx,8), %rdi
callq 0x6190
movq %rax, %r12
testl %ebx, %ebx
jle 0x1a9dc
movl %r13d, %ebx
xorl %r13d, %r13d
leaq 0x1(%... | /rafat[P]ctsa/src/initest.c |
pacf_mle | void pacf_mle(double* vec, int N, double* par, int M) {
// Using Box-Jenkins Conditional MLE
double var, thetac, eps;
double *phi, *theta, *varcovar, *res;
int i, p, mean, k,ret;
res = (double*)malloc(sizeof(double)* N);
theta = (double*)malloc(sizeof(double)* 0);
eps = macheps();
mean = 1;
for (i = 0; i < ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebx
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movl %esi, -0x2c(%rbp)
movslq %esi, %rdi
shlq $0x3, %rdi
callq 0x6190
movq %rax, -0x40(%rbp)
xorl %edi, %edi
callq 0x6190
movq %rax, -0x38(%rbp)
xorl %eax, %ea... | /rafat[P]ctsa/src/initest.c |
macheps | double macheps() {
double macheps;
macheps = 1.0;
while ((macheps + 1.0) > 1.0) {
macheps = macheps / 2.0;
}
macheps = macheps * 2;
return macheps;
} | pushq %rbp
movq %rsp, %rbp
movsd 0x385a4(%rip), %xmm1 # 0x530a0
movsd 0x3933c(%rip), %xmm2 # 0x53e40
movapd %xmm1, %xmm0
mulsd %xmm2, %xmm0
movapd %xmm0, %xmm3
addsd %xmm1, %xmm3
ucomisd %xmm1, %xmm3
ja 0x1ab08
addsd %xmm0, %xmm0
popq %rbp
retq
| /rafat[P]ctsa/src/matrix.c |
signx | double signx(double x) {
double sgn;
if (x >= 0.) {
sgn = 1.0;
}
else {
sgn = -1.0;
}
return sgn;
} | pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
setb %al
leaq 0x393ca(%rip), %rcx # 0x53f30
movsd (%rcx,%rax,8), %xmm0
popq %rbp
retq
| /rafat[P]ctsa/src/matrix.c |
compare | int compare (const void* ind1, const void* ind2)
{
if (*((vipair *)ind1)->a > *((vipair *)ind2)->a)
return -1;
else if (*((vipair *)ind1)->a < *((vipair *)ind2)->a)
return 1;
else
return 0;
} | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movsd (%rax), %xmm0
movq (%rsi), %rax
movsd (%rax), %xmm1
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
ucomisd %xmm1, %xmm0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
popq %rbp
retq
| /rafat[P]ctsa/src/matrix.c |
compare_ascending | int compare_ascending (const void* ind1, const void* ind2)
{
if (*((vipair *)ind1)->a > *((vipair *)ind2)->a)
return 1;
else if (*((vipair *)ind1)->a < *((vipair *)ind2)->a)
return -1;
else
return 0;
} | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movsd (%rax), %xmm0
movq (%rsi), %rax
movsd (%rax), %xmm1
xorl %ecx, %ecx
ucomisd %xmm0, %xmm1
seta %cl
negl %ecx
ucomisd %xmm1, %xmm0
movl $0x1, %eax
cmovbel %ecx, %eax
popq %rbp
retq
| /rafat[P]ctsa/src/matrix.c |
sort1d | void sort1d(double* v,int N, int* pos)
{
vipair* val = NULL;
int i;
if (N <= 0)
return;
val = malloc(sizeof(vipair) * N);
for (i = 0; i < N; ++i) {
val[i].a = &v[i];
val[i].b = i;
}
qsort(val, N, sizeof(vipair), compare);
for (i = 0; i < N; ++i)
pos[i... | testl %esi, %esi
jle 0x1ac96
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r12
movl %esi, %r14d
movq %r14, %rdi
shlq $0x4, %rdi
callq 0x6190
movq %rax, %r15
leaq (,%r14,8), %rax
xorl %ecx, %ecx
xorl %edx, %edx
leaq (%r12,%rcx), %rsi
movq %rsi, (%r15,%rcx,2)
movl %edx... | /rafat[P]ctsa/src/matrix.c |
rtranspose | void rtranspose(double *m, int rows, int cols,double *n, int r, int c) {
register int i,j;
int rm,cm;
int rm1,cm1,rm2,cm2;
int block;
block = (int) BLOCKSIZE;
if (rows <= block && cols <= block) {
for (i = 0; i < rows; ++i) {
for (j = 0; j < cols; ++j) {
n[i+j*r] = m[j+i*c];
//cout << *(n+i+j*r) <<... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
cmpl $0x41, %esi
setl %cl
cmpl $0x41, %edx
setl %al
movb %cl, -0x29(%rbp)
testb %al, %cl
je 0x1afb1
testl %r1... | /rafat[P]ctsa/src/matrix.c |
ctranspose | void ctranspose(double *sig, int rows, int cols,double *col) {
int r,c;
int block;
block = (int) BLOCKSIZE;
r= rows;
c = cols;
if (rows >= block || cols >= block) {
rtranspose(sig,rows,cols,col,r,c);
} else {
stranspose(sig,rows,cols,col);
}
} | cmpl $0x40, %esi
setl %al
cmpl $0x40, %edx
setl %r8b
testb %r8b, %al
jne 0x1b0a2
movl %esi, %r8d
movl %edx, %r9d
jmp 0x1af1d
testl %esi, %esi
jle 0x1b0f8
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %eax
movl %edx, %esi
leaq (,%rax,8), %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
testl %edx, %edx
jle 0x1b0e5
mo... | /rafat[P]ctsa/src/matrix.c |
mdisplay | void mdisplay(double *A, int row, int col) {
int i,j;
printf("\n MATRIX Order : %d X %d \n \n",row,col);
for (i = 0; i < row; i++) {
printf("R%d: ",i);
for ( j = 0; j < col;j++) {
printf("%g ",A[i*col + j]);
}
printf(":R%d \n",i);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
leaq 0x38a2d(%rip), %rdi # 0x53f40
movl %edx, -0x2c(%rbp)
xorl %eax, %eax
callq 0x60d0
testl %r15d, %r15d
jle 0x1b592
movl -0x2c(%rbp), %r13d
movl %r15d, %eax
movq %rax, -0x40(%rbp)
le... | /rafat[P]ctsa/src/matrix.c |
madd | void madd(double* A, double* B, double* C,int rows,int cols) {
int N,i;
/*
* C = A + B . All matrices have identical dimensions rows X cols
*/
N = rows * cols;
#pragma omp parallel for
for (i = 0; i < N; ++i) {
C[i] = A[i] + B[i];
}
} | pushq %rbp
movq %rsp, %rbp
imull %r8d, %ecx
testl %ecx, %ecx
jle 0x1b5c8
movl %ecx, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm0
addsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1b5b1
popq %rbp
retq
| /rafat[P]ctsa/src/matrix.c |
msub | void msub(double* A, double* B, double* C,int rows,int cols) {
int N,i;
/*
* C = A - B . All matrices have identical dimensions rows X cols
*/
N = rows * cols;
#pragma omp parallel for
for (i = 0; i < N; ++i) {
C[i] = A[i] - B[i];
}
} | pushq %rbp
movq %rsp, %rbp
imull %r8d, %ecx
testl %ecx, %ecx
jle 0x1b5f1
movl %ecx, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm0
subsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1b5da
popq %rbp
retq
| /rafat[P]ctsa/src/matrix.c |
scale | void scale(double *A, int rows, int cols, double alpha) {
int N,i;
/*
* A = alpha * A
* Matrix A is overwritten.
*/
N = rows * cols;
#pragma omp parallel for
for (i = 0; i < N;++i) {
A[i] = alpha * A[i];
}
} | pushq %rbp
movq %rsp, %rbp
imull %edx, %esi
testl %esi, %esi
jle 0x1b618
movl %esi, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1b602
popq %rbp
retq
| /rafat[P]ctsa/src/matrix.c |
nmult | void nmult(double* A, double* B, double* C,int ra,int ca, int cb) {
register int i,j,k;
int u,v,t,rb;
/*
* C = A * B , where A is a ra*ca matric while B is a rb*cb
* with ca = rb
* Matrix C is a ra*cb matrix
*/
rb = ca;
#pragma omp parallel for private(i,j,k,v,u,t)
for (i = 0; i < ra; ++i) {
for (... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
testl %ecx, %ecx
jle 0x1b6c2
movl %r9d, %eax
movl %ecx, %edi
movl %r8d, %r10d
leaq (,%rax,8), %r11
xorl %ebx, %ebx
xorl %r14d, %r14d
testl %r9d, %r9d
jle 0x1b6b7
movl %e... | /rafat[P]ctsa/src/matrix.c |
recmult | void recmult(double* A, double* B, double* C,int m,int n, int p,int sA,int sB, int sC) {
int m2,n2,p2;
register int i,j,k;
int u,v,t;
if (m + n + p <= CUTOFF) {
//#pragma omp parallel for private(i,j,k,v,u,t)
for (i = 0; i < m; ++i) {
for (j = 0; j < p; ++j) {
v = i * sB;
u = i * sC;
t = j + u;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movl %r8d, %r14d
movl %ecx, %r12d
movq %rdx, %r15
movq %rsi, -0x40(%rbp)
movq %rdi, %r13
leal (%r14,%r12), %eax
movq %rax, -0x48(%rbp)
addl %ebx, %eax
cmpl $0xc1, %eax
jge 0x1b8a2
testl %r12d, %r12d
jle 0x... | /rafat[P]ctsa/src/matrix.c |
rmult | void rmult(double* A, double* B, double* C,int m,int n, int p) {
int strA,strB,strC;
int N;
register int i;
strA = m;
strB = n;
strC = p;
N = m * p;
for(i = 0; i < N; ++i) {
C[i] = 0.;
}
recmult(A,B,C,m,n,p,strA,strB,strC);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r15d
movl %r8d, %r14d
movl %ecx, %ebx
movq %rdx, %r12
movq %rdi, %r13
movl %r9d, %eax
imull %ecx, %eax
testl %eax, %eax
jle 0x1baa2
movl %eax, %edx
shlq $0x3, %rdx
movq %r12, %rdi
movq %rsi, -0x30(%rbp)
xorl %esi, %... | /rafat[P]ctsa/src/matrix.c |
findrec | int findrec(int *a, int *b, int *c) {
int rec;
double da,db,dc,mul;
da = (double) *a;
db = (double) *b;
dc = (double) *c;
rec = 0;
mul = 1.;
while (da + db + dc > (double) CUTOFF) {
rec++;
mul *= 2;
da = ceil(da/2.);
db = ceil(db/2.);
dc = ceil(dc/2.);
}
*a = (int) da * mul;
*b = (int) db * mul;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cvtsi2sdl (%rdi), %xmm4
cvtsi2sdl (%rsi), %xmm3
cvtsi2sdl (%rdx), %xmm0
movapd %xmm4, %xmm1
addsd %xmm3, %xmm1
addsd %xmm0, %xmm1
ucomisd 0x3840b(%rip), %xmm1 # 0x53f10
jbe 0x1bb96
... | /rafat[P]ctsa/src/matrix.c |
add_zero_pad | void add_zero_pad(double *X, int rows, int cols, int zrow, int zcol,double *Y) {
int r,c,i,j,u,v;
r = rows + zrow;
c = cols + zcol;
for (i = 0; i < rows;++i) {
u = i*c;
v = i * cols;
for (j = 0; j < cols;++j) {
Y[u + j] = X[v + j];
}
for (j = cols; j < c;++j) {
Y[u + j] = 0.;
}
}
for (i = ro... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x38(%rbp)
movl %ecx, -0x3c(%rbp)
movl %edx, %r9d
movl %esi, %r15d
movq %r8, -0x68(%rbp)
leal (%r8,%r9), %eax
movq %rax, -0x30(%rbp)
testl %esi, %esi
jle 0x1bcc4
movq %rdi, %r14
leal 0x1(%r9), %eax
movq -0x30(%... | /rafat[P]ctsa/src/matrix.c |
remove_zero_pad | void remove_zero_pad(double *Y, int rows, int cols, int zrow, int zcol,double *Z) {
int r,c,i,j,u,v;
r = rows - zrow;
c = cols - zcol;
for (i = 0; i < r; ++i) {
u = i * c;
v = i * cols;
for (j = 0; j < c; ++j) {
Z[j + u] = Y[j + v];
}
}
} | subl %ecx, %esi
jle 0x1bd63
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
subl %r8d, %edx
movslq %edx, %rcx
movl %esi, %esi
shlq $0x3, %rcx
shlq $0x3, %rax
xorl %r8d, %r8d
testl %edx, %edx
jle 0x1bd54
xorl %r10d, %r10d
movsd (%rdi,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rdx
jne 0x1bd40
incq %r8
ad... | /rafat[P]ctsa/src/matrix.c |
madd_stride | void madd_stride(double* A, double* B, double* C,int rows,int cols,int sA,int sB,int sC) {
int i,j,u,v,w;
for (i = 0; i < rows; ++i) {
u = i * sC;
v = i * sA;
w = i * sB;
for(j = 0; j < cols;j++) {
C[j + u] = A[j + v] + B[j + w];
}
}
} | testl %ecx, %ecx
jle 0x1bdc4
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movslq 0x18(%rbp), %rax
movslq %r9d, %r9
movslq 0x10(%rbp), %r10
movl %ecx, %ecx
movl %r8d, %r11d
shlq $0x3, %rax
shlq $0x3, %r10
shlq $0x3, %r9
xorl %ebx, %ebx
testl %r8d, %r8d
jle 0x1bdaf
xorl %r14d, %r14d
movsd (%rdi,%r14,8), %xmm0
addsd (... | /rafat[P]ctsa/src/matrix.c |
rmadd_stride | void rmadd_stride(double* A, double* B, double* C,int rows,int cols,int p,int sA,int sB,int sC) {
int i,j,u,v,w;
if (rows + cols + p <= CUTOFF) {
for (i = 0; i < rows; ++i) {
u = i * sC;
v = i * sA;
w = i * sB;
for(j = 0; j < cols;j++) {
C[j + u] = A[j + v] + B[j + w];
}
}
} else {
rows... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x18(%rbp), %r11d
leal (%r8,%rcx), %eax
addl %r9d, %eax
cmpl $0xc1, %eax
jge 0x1be5d
movl %ecx, %r13d
movl %r8d, %r10d
jmp 0x1bf6b
movl %r9d, %r12d
movl %ecx, %r13d
shr... | /rafat[P]ctsa/src/matrix.c |
marsaglia_generate | double* marsaglia_generate(double *values, int N, double average, double deviation)
{
int i;
int M;
double x, y, rsq, f;
M = N + N % 2;
for (i = 0; i < N - 1; i += 2)
{
do {
x = 2.0 * rand() / (double)RAND_MAX - 1.0;
y = 2.0 * rand() / (double)RAND_MAX - 1.0;
rsq = x * x + y * y;
} while (rsq >=... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movapd %xmm0, %xmm2
movl %esi, %r14d
movq %rdi, %rbx
leal -0x1(%r14), %r15d
cmpl $0x2, %esi
movsd %xmm1, -0x38(%rbp)
movsd %xmm0, -0x30(%rbp)
jl 0x1def1
xorl %r12d, %r12d
callq 0x6250
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
addsd %x... | /rafat[P]ctsa/src/matrix.c |
linsolve | void linsolve(double *A,int N,double *b,int *ipiv,double *x) {
int i,j,c1,l;
double *y;
double sum;
y = (double*) malloc(sizeof(double) *N);
/*
* Two step Solution L * U * x = b
* Let U*x = y
* Solve L * y = b for y (Forward Substitution
* Solve U * x = b for x (Back Substitution)
*/
for(i = 0; i < N... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, -0x50(%rbp)
movq %rdx, %r13
movl %esi, %ebx
movq %rdi, -0x30(%rbp)
movslq %esi, %r14
leaq (,%r14,8), %rdi
callq 0x6190
movq %rax, %r12
movl %r14d, %r15d
testl %r14d, %r14d
jle 0x1e121
movq... | /rafat[P]ctsa/src/matrix.c |
house_2 | double house_2(double*x,int N,double *v) {
double sgn,beta,sc;
double *sigma,*e;
int i;
sigma = (double*) malloc(sizeof(double) * 1);
e = (double*) malloc(sizeof(double) * N);
beta = 2.0;
sgn = 1.0;
mmult(x,x,sigma,1,N,1);
sigma[0] = sqrt(sigma[0]);
e[0] =1.;
for (i = 1; i < N;++i) {
e[i] = 0.;
}
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r13
movl $0x8, %edi
callq 0x6190
movq %rax, %r12
movq %r14, -0x30(%rbp)
movslq %r14d, %r14
leaq (,%r14,8), %rdi
callq 0x6190
movq %rax, %r15
movq %r13, %rdi
movq %r13, %rsi
mov... | /rafat[P]ctsa/src/matrix.c |
cholu | int cholu(double *A, int N) {
int stride,i,j,t,sc;
double *U22;
U22 = (double*) malloc(sizeof(double) * N * N);
stride = N;
sc = rcholu(A,N,stride,U22);
for(i=0; i < N;++i) {
t = i *N;
for(j=0;j < i;++j) {
A[t+j] = 0.;
}
}
free(U22);
return sc;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r13
movq %r13, %rdi
imulq %r13, %rdi
shlq $0x3, %rdi
callq 0x6190
movq %r14, %rdi
movl %r13d, %esi
movl %r13d, %edx
movq %rax, -0x38(%rbp)
movq %rax, %rcx
callq 0x20d07
movl %... | /rafat[P]ctsa/src/matrix.c |
rcholu | static int rcholu(double *A,int N, int stride, double *U22) {
int sc;
int j,i,u,w;
double u11;
if (N == 1) {
if (A[0] > 0) {
A[0] = sqrt(A[0]);
return 0;
} else {
return -1;
}
} else {
if (A[0] < 0) {
return -1;
}
u11 = sqrt(A[0]);
A[0] = u11;
for (j = 1; j < N;++j) {
A[j] /= u11;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
je 0x20e41
movq %rcx, -0x30(%rbp)
movslq %edx, %rax
incl %edx
movslq %edx, %rcx
leal -0x1(%rsi), %r13d
movslq %esi, %r15
leaq 0x8(,%rax,8), %r14
leaq (%rbx,%rcx,8), %r8
xorpd %xmm1, %xmm1
m... | /rafat[P]ctsa/src/matrix.c |
chol | int chol(double *A, int N) {
int sc;
if ( N <= (int) BLOCKSIZE) {
sc = cholu(A,N);
} else {
sc = bcholu(A,N);
}
return sc;
} | pushq %rbp
movq %rsp, %rbp
cmpl $0x40, %esi
jg 0x21219
popq %rbp
jmp 0x20c77
popq %rbp
jmp 0x20e7d
| /rafat[P]ctsa/src/matrix.c |
svd_sort | void svd_sort(double *U,int M,int N,double *V,double *q) {
/*
* Pavel Sakov's CSA SVD sort routine is used with some minor
* modifications. See The License below
*/
/*
* Copyright (C) 2000-2008 Pavel Sakov and CSIRO
Redistribution and use of material from the package `csa', with or without
modification, are ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x58(%rbp)
movq %rcx, %r14
movl %edx, %r15d
movq %rdi, %r13
movslq %edx, %rbx
leaq (,%rbx,8), %r12
movl %esi, -0x30(%rbp)
movslq %esi, %rdi
imulq %r12, %rdi
callq 0x6190
movq %rax, -0x48(%rbp)
movq %r12, %rdi
i... | /rafat[P]ctsa/src/matrix.c |
svd | int svd(double *A,int M,int N,double *U,double *V,double *q) {
int i,j,k,l,t,t2,ierr,cancel,iter,l1;
double eps,g,x,s,temp,f,h,c,y,z,scale;
double *e;
/*
THIS SUBROUTINE IS THE MODIFIED C TRANSLATION OF THE
EISPACK FORTRAN TRANSLATION OF THE ALGOL PROCEDURE SVD,
NUM. MATH. 14, 403-420(1970) BY GOLUB ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
cmpl %edx, %esi
jge 0x215b0
leaq 0x32af2(%rip), %rdi # 0x54085
callq 0x60a0
leaq 0x32a2e(%rip), %rdi # 0x53fcd
xorl %eax, %eax
callq 0x60d0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF... | /rafat[P]ctsa/src/matrix.c |
svd_transpose | int svd_transpose(double *A, int M, int N, double *U, double *V, double *q) {
int ret;
/* Call this routine if M < N
* U = MXM
* V - NXM
* Q - MX1
* A = (V * diag(Q) * U' )'
*/
if (M >= N) {
printf("M>=N. Use svd routine.\n");
exit(-1);
}
mtranspose(A, M, N, V);
ret = svd(V, N, M, V, U, q);
return re... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl %edx, %esi
jge 0x227d8
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movl %edx, %r13d
movl %esi, %r12d
movq %r8, %rcx
callq 0x1b0f9
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
movq %r15, %rcx
movq %r14, %r8
movq %rbx... | /rafat[P]ctsa/src/matrix.c |
fdjac | void fdjac(custom_gradient *funcgrad, double *x, int N, double *jac, double *dx, double eps2, double *J) {
int i,j;
double stepsize,temp,stepmax;
double *fj;
fj = (double*) malloc(sizeof(double) *N);
for(j = 0; j < N;++j) {
if (fabs(x[j]) >= (1.0 / fabs(dx[j]))) {
stepmax = x[j];
} else {
stepmax = si... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movsd %xmm0, -0x50(%rbp)
movq %r8, -0x40(%rbp)
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, -0x48(%rbp)
movl %edx, -0x2c(%rbp)
movslq %edx, %rbx
leaq (,%rbx,8), %rdi
callq 0x6190
movq %r14, %rdx
movq %rax, %r... | /rafat[P]ctsa/src/newtonmin.c |
hessian_fdg | void hessian_fdg(custom_gradient *funcgrad, double *x, int N, double *jac, double *dx, double eps2, double *H) {
int i,j,k;
fdjac(funcgrad,x,N,jac,dx,eps2,H);
for(i = 0; i < N;++i) {
k = i * N;
for(j = 0; j < N;++j) {
H[k + j] = (H[k + j] + H[j*N + i]) / 2.0;
}
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %r9, %rbx
movl %edx, %r14d
callq 0x23f3c
testl %r14d, %r14d
jle 0x240ee
movl %r14d, %eax
leaq (,%rax,8), %rcx
xorl %edx, %edx
movsd 0x2fd89(%rip), %xmm0 # 0x53e40
movq %rbx, %rsi
movq %rbx, %rdi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm1
addsd (%rdi), %xmm1
mulsd ... | /rafat[P]ctsa/src/newtonmin.c |
hessian_opt | int hessian_opt(custom_function *funcpt, custom_gradient *funcgrad, double *x, int N, double *jac,
double *dx,double eps,double eps2,double *H) {
int retval;
retval = 0;
if (funcgrad == NULL) {
//printf("HESSF \n");
retval = hessian_fd(funcpt,x,N,dx,eps,H);
} else {
//printf("HESSG \n");
hessian_fdg(funcg... | pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
testq %rsi, %rsi
je 0x2411d
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movq %r8, %rcx
movq %r9, %r8
movaps %xmm1, %xmm0
movq %rax, %r9
callq 0x2408b
xorl %eax, %eax
popq %rbp
retq
movq %rdx, %rsi
movl %ecx, %edx
movq %r9, %rcx
movq %rax, %r8
popq %rbp
jmp 0x237c8
| /rafat[P]ctsa/src/newtonmin.c |
lnsrch | int lnsrch(custom_function *funcpt,double *xi,double *jac,double *p,int N,double * dx,double maxstep,double stol,double *x) {
int retval,i,iter,MAXITER;
double alpha,lambda,lambdamin,funcf,funci,lambdaprev,lambdatemp,funcprev;
double lambda2,lambdaprev2,ll,den,rell,nlen;
double *slopei,*temp1,*temp2,*ab,*rcheck,*pl... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movsd %xmm1, -0x70(%rbp)
movsd %xmm0, -0x38(%rbp)
movq %r9, %rbx
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, -0x60(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, -0x98(%rbp)
movl $0x8, %edi
callq 0x6190
movq %rax, -0x48(%rbp)
mo... | /rafat[P]ctsa/src/newtonmin.c |
lnsrchmod | int lnsrchmod(custom_function *funcpt, custom_gradient *funcgrad, double *xi, double *jac, double *p, int N, double * dx, double maxstep,
double eps2,double stol,double *x,double *jacf) {
int retval,i,gfdcode;
double alpha,lambda,lambdamin,funcf,funci,lambdaprev,lambdatemp,funcprev;
double lambda2,lambdaprev2,ll,d... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movsd %xmm2, -0x88(%rbp)
movsd %xmm1, -0xd0(%rbp)
movsd %xmm0, -0x38(%rbp)
movl %r9d, %r14d
movq %r8, %r15
movq %rcx, -0x50(%rbp)
movq %rdx, %r12
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x60(%rbp)
movl $0x8, %edi
callq 0x6190
... | /rafat[P]ctsa/src/newtonmin.c |
lnsrchcg | int lnsrchcg(custom_function *funcpt, custom_gradient *funcgrad, double *xi, double *jac, double *p, int N, double * dx, double maxstep,
double eps2,double stol,double *x,double *jacf) {
int retval,i,gfdcode;
double alpha,lambda,lambdamin,funcf,funci,lambdaprev,lambdatemp,funcprev;
double lambda2,lambdaprev2,ll,den... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movsd %xmm2, -0x88(%rbp)
movsd %xmm1, -0xe0(%rbp)
movsd %xmm0, -0xd0(%rbp)
movl %r9d, %r14d
movq %r8, %r15
movq %rcx, -0x38(%rbp)
movq %rdx, %rbx
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x50(%rbp)
mov... | /rafat[P]ctsa/src/newtonmin.c |
stopcheck | int stopcheck(double fx,int N,double *xc,double *xf,double *jac,double *dx,double fsval,double gtol,double stol,int retval) {
int rcode,i;
double num,den;
double stop0;
double *scheck;
rcode = 0;
if (retval == 1) {
rcode = 3;
return rcode;
}
if (retval == 5) {
rcode = 5;
return rcode;
}
if (retval ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %r9d
je 0x25fd5
movl %r9d, %r13d
cmpl $0xf, %r9d
je 0x26026
cmpl $0x5, %r13d
je 0x26026
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movl %edi, %eax
movapd %xmm1, -0x50(%rbp)
movapd %xmm0, -0x60(%rbp)
movsd %... | /rafat[P]ctsa/src/newtonmin.c |
newton_min_func | int newton_min_func(custom_function *funcpt, custom_gradient *funcgrad, double *xi, int N, double *dx, double fsval, double maxstep, int MAXITER,
int *niter,double eps,double gtol,double stol,double *xf) {
int rcode,gfdcode,hdcode;
int i,siter,retval;
double dt1,dt2,eps2;
double fx,num,den,stop0,fxf;
double *jac... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movsd %xmm4, -0xb0(%rbp)
movsd %xmm3, -0x98(%rbp)
movsd %xmm2, -0x50(%rbp)
movl %r9d, -0x9c(%rbp)
movsd %xmm1, -0x38(%rbp)
movapd %xmm0, -0xe0(%rbp)
movq %r8, %r14
movq %rdx, %r13
movq %rsi, -0x80(%rbp)
movq %rdi, -0x58(%... | /rafat[P]ctsa/src/newtonmin.c |
trsrch | int trsrch(custom_function *funcpt,double *xi,double *jac,double *sN,int N,double * dx,double maxstep,
int iter,double *L,double *hess,double stol,double *ioval,double eps,double *x) {
int retval,i,j,method;
double alpha,beta;
double nlen,t1,funcprev;
double *temp,*step,*xprev;
/*
* ioval[0] = delta; [trust ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movsd %xmm2, -0x88(%rbp)
movsd %xmm1, -0x80(%rbp)
movsd %xmm0, -0x48(%rbp)
movq %r9, %rbx
movl %r8d, %r13d
movq %rcx, -0x60(%rbp)
movq %rdx, %r12
movq %rsi, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq 0x28(%rbp), %rcx
movabsq... | /rafat[P]ctsa/src/newtonmin.c |
trupdate | int trupdate(custom_function *funcpt,double *xi,double *jac,double *step,int N,double * dx,double maxstep,
int retcode,double *L,double *hess,double stol,int method,double *ioval,double *xprev,double *funcprev,double *x) {
int retval;
int i,j,c1;
double delta,alpha,nlen,rell,den,deltatemp;
double funci,funcf... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movsd %xmm1, -0x80(%rbp)
movsd %xmm0, -0x58(%rbp)
movq %r9, %r12
movl %r8d, %r15d
movq %rcx, %r13
movq %rdx, -0x88(%rbp)
movq %rsi, -0x50(%rbp)
movq %rdi, %r14
movq 0x30(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(... | /rafat[P]ctsa/src/newtonmin.c |
trstep_ddl | void trstep_ddl(double *jac,double *sN,int N,double * dx,double maxstep,double *L,double *hess,double nlen,double *ioval,
double *ssd,double *v,double *step) {
int i,j;
double tvec,temp;
double alpha,beta;
double delta,clen,neta,lambda;
double *temp1,*slstep;
double *t1,*t2;
delta = ioval[0];clen = ioval[1... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movsd %xmm1, -0xa0(%rbp)
movq %r8, %r12
movsd %xmm0, -0xb0(%rbp)
movq %rcx, %r13
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, -0x60(%rbp)
movq 0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0x98(... | /rafat[P]ctsa/src/newtonmin.c |
nls_init | nls_object nls_init(int M,int N) {
nls_object obj = NULL;
int i;
double meps;
obj = (nls_object) malloc (sizeof(struct nls_set) + sizeof(double)* (N-1));
meps = macheps();
obj->eps = meps;
obj->epsfcn = meps;
obj->factor = 100.; //Takes values between 0.1 and 100.0
obj->xtol = meps;
obj->gtol = pow(meps,(do... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movl %edi, %r15d
movslq %esi, %r12
leaq 0x58(,%r12,8), %rdi
callq 0x6190
movq %rax, %rbx
xorl %eax, %eax
callq 0x1aaf0
movsd %xmm0, 0x8(%rbx)
movsd %xmm0, 0x10(%rbx)
movabsq $0x4059000000000000, %rax # imm = 0x4059000000000000
movq ... | /rafat[P]ctsa/src/optimc.c |
fminunc | int fminunc(custom_function *funcpt, custom_gradient *funcgrad, int N, double *xi,double maxstep, int method,double *xf) {
int i,retval,MAXITER,niter,m;
double fsval,eps,gtol,stol,ftol,xtol,delta;
double *dx;
dx = (double*) malloc(sizeof(double) * N);
/*
* Method 0 - Nelder-Mead
* Method 1 - Newton Line Se... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x48(%rbp)
movl %r8d, %r12d
movsd %xmm0, -0x58(%rbp)
movq %rcx, -0x40(%rbp)
movl %edx, %r15d
movq %rsi, -0x50(%rbp)
movq %rdi, %r14
movslq %edx, %rdi
shlq $0x3, %rdi
callq 0x6190
movq %rax, %rbx
movl $0x0, -0x2... | /rafat[P]ctsa/src/optimc.c |
CDIVID | static void CDIVID(double *AR, double *AI, double *BR, double *BI, double INFINY, double *CR, double *CI) {
// C COMPLEX DIVISION C = A/B, AVOIDING OVERFLOW.
double INFIN,R,D;
if ( !(*BR != 0.0 || *BI != 0.0) ) {
INFIN = INFINY;
*CR = *CI = INFIN;
}
else {
if (fabs(*BR) < fabs(*BI)) {
R = *BR / *BI;
D ... | xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm0
movsd (%rdx), %xmm2
jne 0x2ac2e
jp 0x2ac2e
ucomisd %xmm3, %xmm2
jne 0x2ac2e
jp 0x2ac2e
movsd %xmm1, (%r8)
movsd %xmm1, (%rcx)
retq
pushq %rbp
movq %rsp, %rbp
movapd 0x284e6(%rip), %xmm1 # 0x53120
movapd %xmm0, %xmm3
andpd %xmm1, %xmm3
andpd %xmm2, %xmm1
ucomisd %xmm3, %xmm1
mo... | /rafat[P]ctsa/src/polyroot.c |
polyroot | int polyroot(double *coeff, int DEGREE, double *ZEROR, double *ZEROI) {
/*
Input - coeff[0] + coeff[1] * x^1 + coeff[2] * x^2 + ---- + coeff[DEGREE+1] * x^DEGREE
The program fails if there are leading zeros. Check return value.
Return Value = 0 -> Probable Success
Return Value = 1 -> Likely Failure
*/
int fai... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movl %esi, %r15d
movq %rdi, %r14
leal 0x1(%r15), %ebx
movslq %ebx, %r13
shlq $0x3, %r13
movq %r13, %rdi
callq 0x6190
movq %rax, %r12
movq %r13, %rdi
callq 0x6190
movq %rax, %r... | /rafat[P]ctsa/src/polyroot.c |
cpolyroot | int cpolyroot(double *rcoeff,double *icoeff, int DEGREE, double *ZEROR, double *ZEROI) {
/*
Input - rcoeff[0]+i*icoeff[0] + (rcoeff[1] + i*icoeff[1]) * x^1 + (rcoeff[2] + i*icoeff[2]) * x^2 + ---- + (rcoeff[DEGREE+1] + i*icoeff[DEGREE+1]) * x^DEGREE
The program fails if there are leading zeros [At least one coeffic... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbx
leal 0x1(%r15), %eax
movl %eax, -0x2c(%rbp)
movslq %eax, %r14
shlq $0x3, %r14
movq %r14, %rdi
callq 0x6190
movq %rax, %r12
movq... | /rafat[P]ctsa/src/polyroot.c |
POLYEV | static void POLYEV(int NN, double *SR, double *SI,double *PR, double *PI, double *QR, double *QI, double *PVR, double *PVI) {
double T;
int i;
QR[0] = PR[0];
QI[0] = PI[0];
*PVR = QR[0];
*PVI = QI[0];
for (i = 1; i < NN; ++i) {
T = *PVR * *SR - *PVI * *SI + PR[i];
*PVI = *PVR * *SI + *PVI * *SR + PI[i];
*... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %r10
movq 0x10(%rbp), %r11
movsd (%rcx), %xmm0
movsd %xmm0, (%r9)
movsd (%r8), %xmm0
movsd %xmm0, (%r11)
movsd (%r9), %xmm0
movsd %xmm0, (%r10)
movsd (%r11), %xmm0
movsd %xmm0, (%rax)
cmpl $0x2, %edi
jl 0x2aebf
movl %edi, %edi
movl $0x1, %ebx
... | /rafat[P]ctsa/src/polyroot.c |
CALCT | static void CALCT(int *BOOL, int NN, double *SR, double *SI, double *HR, double *HI,double *QHR, double *QHI,double ARE, double INFINY,double *PVR, double *PVI,double *TR, double *TI ) {
/*
C COMPUTES T = -P(S)/H(S).
C BOOL - LOGICAL, SET TRUE IF H(S) IS ESSENTIALLY ZERO.
*/
double HVR, HVI, pvrt,pvit;
int N;
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movapd %xmm0, %xmm2
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %r10
movsd (%r8), %xmm0
movsd %xmm0, (%r10)
movsd (%r9), %xmm3
movsd %xmm3, (%rax)
movsd (%r10), %xmm0
movsd %xmm3, -0x10(%rbp)
cmpl $0x3, %esi
jl 0x2af4a
leal -0x1(%rsi), %r11d
movl $0x1, %ebx
movapd %xmm0... | /rafat[P]ctsa/src/polyroot.c |
VRSHFT | static void VRSHFT(int NN, int L3, double *ZR, double *ZI, int *CONV,double *SR, double *SI,double *PR, double *PI, double *QPR, double *QPI, double *PVR, double *PVI,
double ARE, double MRE, double ETA, double INFIN, double *HR, double *HI, double *QHR, double *QHI, double *SHR, double *SHI, double *TR, double *TI) {... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movsd %xmm2, -0xb0(%rbp)
movq 0x48(%rbp), %r13
movq %rsi, -0x98(%rbp)
movsd (%rsi), %xmm2
movq %r8, -0x40(%rbp)
movsd %xmm2, (%r8)
movq %rdx, -0xa8(%rbp)
movsd (%rdx), %xmm2
movq %r9, -0x38(%rbp)
movsd %xmm2, (%r9)
movq %... | /rafat[P]ctsa/src/polyroot.c |
reg_init | reg_object reg_init(int N, int p) {
reg_object obj = NULL;
int i;
/*
* reg_init initializes the regression object.
* N - number of observation samples. All variables (indepnedent and dependent)
* are of identical length N.
*
* p - Total Number of variables (independent and dependent).
* The base case is p = 2 ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
js 0x2b8b8
movl %esi, %r15d
movl %edi, %r12d
movl %esi, %edi
shlq $0x5, %rdi
leaq 0x20(%rdi), %rbx
addq $0xf0, %rdi
callq 0x6190
movq %rax, %r14
movl %r12d, (%rax)
movl %r15d, 0x4(%rax)
movabsq $0x3fa999999999999a, %rax # imm = 0x3F... | /rafat[P]ctsa/src/regression.c |
zerohyp_val | void zerohyp_val(reg_object obj, double *tval, double *pval) {
int df, i;
/*
* Zero Hypothesis Test for CLRM
*/
df = obj->N - obj->p;
printf("\n");
printf("%-25s \n", "Zero Hypothesis Test t values and Probabilities (One-tailed)");
printf("%-25s%-20s%-20s \n", "Coefficients", "t Value", "Probability");
if (df... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movl (%rdi), %r15d
movq %rdi, -0x30(%rbp)
movl 0x4(%rdi), %ebx
movl $0xa, %edi
callq 0x6050
leaq 0x2813a(%rip), %rdi # 0x5487e
leaq 0x2813b(%rip), %rsi # 0x54886
xorl %eax, %eax
callq 0x6... | /rafat[P]ctsa/src/regression.c |
confint | void confint(reg_object obj) {
int i;
printf("\n");
printf("%-10lf%% Confidence Interval For Parameters And Residual Variance : \n", (1.0 - obj->alpha) * 100);
printf("%-25s%-20s%-20s%-20s \n", "Parameters",
"Value", "Lower Limit", "Upper Limit");
for (i = 0; i < obj->p; ++i) {
printf("B%-25d%-20lf%-20lf%-20l... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0xa, %edi
callq 0x6050
movsd 0x2605b(%rip), %xmm0 # 0x530a0
subsd 0x8(%rbx), %xmm0
mulsd 0x2722e(%rip), %xmm0 # 0x54280
leaq 0x27a5c(%rip), %rdi # 0x54ab5
movb $0x1, %al
callq 0x60d0
leaq 0x279eb(%rip), %rdi # 0x5... | /rafat[P]ctsa/src/regression.c |
upsample | int upsample(double *x,int lenx, int M, double *y) {
int N,i,j,k;
if (M < 0) {
return -1;
}
if (M == 0) {
for (i = 0; i < lenx; ++i) {
y[i] = x[i];
}
return lenx;
}
N = M * (lenx-1) + 1;
j = 1;
k = 0;
for(i = 0; i < N;++i) {
j--;
y[i] = 0.0;
if (j == 0) {
y[i] = x[k];
k++;
j = M;
... | pushq %rbp
movq %rsp, %rbp
testl %edx, %edx
js 0x3043d
movl %esi, %eax
je 0x30444
decl %eax
movl %eax, %esi
imull %edx, %esi
leal 0x1(%rsi), %eax
testl %esi, %esi
js 0x3045e
movl %eax, %esi
movl $0x1, %r10d
xorl %r8d, %r8d
xorl %r9d, %r9d
movq $0x0, (%rcx,%r8,8)
decl %r10d
jne 0x30433
movslq %r9d, %r9
movsd (%rdi,%r9,8... | /rafat[P]ctsa/src/talg.c |
downsample | int downsample(double *x,int lenx, int M, double *y) {
int N,i;
if (M < 0) {
return -1;
}
if (M == 0) {
for (i = 0; i < lenx; ++i) {
y[i] = x[i];
}
return lenx;
}
N = (lenx-1)/M + 1;
for (i = 0;i < N;++i) {
y[i] = x[i*M];
}
return N;
} | testl %edx, %edx
js 0x304a1
movl %esi, %eax
je 0x304a7
movl %edx, %r8d
decl %eax
cltd
idivl %r8d
movl %eax, %edx
leal 0x1(%rdx), %eax
testl %edx, %edx
js 0x304c1
pushq %rbp
movq %rsp, %rbp
movl %r8d, %edx
movl %eax, %esi
shlq $0x3, %rdx
xorl %r8d, %r8d
movsd (%rdi), %xmm0
movsd %xmm0, (%rcx,%r8,8)
incq %r8
addq %rdx, %... | /rafat[P]ctsa/src/talg.c |
deld | void deld(int d, double* C) {
int i,j;
double *vec,*oup;
/*
* deld returns coefficients of [1,-1]^d
* eg.,
* d=2 yields [1,-2,1]
* d=3 [1,-3,3,1]
*/
vec = (double*) malloc(sizeof(double) * 2);
oup = (double*) malloc(sizeof(double) * (d+1));
vec[0] = 1.;
vec[1] = -1.;
oup[0] = 1.;
// oup has length (... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r13d
movl $0x10, %r14d
movl $0x10, %edi
callq 0x6190
movq %rax, %r12
movslq %r13d, %r15
leaq 0x8(,%r15,8), %rdi
callq 0x6190
movq %r12, %rdx
movq %rax, %r12
movabsq $0x3ff0000000000000, %rax # imm = ... | /rafat[P]ctsa/src/talg.c |
delds | void delds(int D, int s, double *C) {
int i,j;
double *vec,*oup;
/*
* delds returns coefficients of [1,....(s-1) zeroes,.. -1]^D
* eg., D =1 s = 4 yields
* [1,0,0,0,-1]
* D=2 s=4 -> [1,0,0,0,-2,0,0,0,1]
*/
/*
* s - seasonal component
* s = 4 (quarterly data), 12 (yearly data) etc.
* D - Differencin... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x50(%rbp)
movl %esi, %r14d
movl %edi, %r12d
leal 0x1(%r14), %r13d
movslq %r13d, %rdi
shlq $0x3, %rdi
callq 0x6190
movq %rax, %r15
movl %r14d, %eax
movl %r12d, %ebx
imull %r12d, %eax
cltq
leaq 0x8(,%rax,8), %r... | /rafat[P]ctsa/src/talg.c |
diff | int diff(double *sig, int N, int d, double *oup) {
int Noup,i,j;
double *coeff;
double sum;
/*
*
* diff output = [ X(t) - X(t-1) ] ^ d where X(t) is the
* input timeseries of length N
* output is of length N - d
*
* diff is used to detrend data
*
* d=1 typically takes care of linear trend while
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, -0x2c(%rbp)
movq %rdi, %r15
leal 0x1(%r14), %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
callq 0x6190
movq %rax, %r13
movl %r14d, %edi
movq %rax, %rsi
callq 0x304c2
movl -0x2c(%rbp), %ecx... | /rafat[P]ctsa/src/talg.c |
diffs | int diffs(double *sig, int N, int D,int s, double *oup) {
int Noup,i,j,d;
double *coeff;
double sum;
/*
* diffs output = [ X(t) - X(t-s) ] ^ D where X(t) is the
* input timeseries of length N
* output is of length N - D*s
*
*
* s - seasonal component, D = 1 when seasonal component is present and 0
*... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movl %ecx, %r13d
movl %edx, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
movq %rdi, %r15
movl %ecx, %r14d
imull %edx, %r14d
movslq %r14d, %rbx
leaq 0x8(,%rbx,8), %rdi
callq 0x6190
movq %rax, %r12
movl -0x2c(%r... | /rafat[P]ctsa/src/talg.c |
deseason_ma | void deseason_ma(double *sig,int N,int s,double *oup) {
double *mt,*w,*seas;
int k,window,q,odd,jd,count,per,it;
double temp,wi;
window = s;
mt = (double*) malloc(sizeof(double) * N);
w = (double*) malloc(sizeof(double) * window);
seas = (double*) malloc(sizeof(double) * window);
mafilter2(sig,N,window,mt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x48(%rbp)
movl %edx, %r15d
movq %rdi, %r12
movl %esi, -0x2c(%rbp)
movslq %esi, %rax
movq %rax, -0x40(%rbp)
leaq (,%rax,8), %rdi
callq 0x6190
movq %rax, -0x38(%rbp)
movslq %r15d, %rbx
leaq (,%rbx,8), %r14
movq... | /rafat[P]ctsa/src/talg.c |
psiweight | void psiweight(double *phi,double *theta,double *psi,int p,int q,int j) {
int i,k;
double temp;
double *th;
psi[0] = 1.0;
th = (double*) malloc(sizeof(double) * (q+1));
th[0] = 1.;
for(i = 0; i < q;++i) {
th[i+1] = theta[i];
}
for(i = 1; i < j;++i) {
psi[i] = 0.0;
temp = 0.0;
if(i <= q) {
psi[i] ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x30(%rbp)
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdx)
movl %r8d, -0x2c(%rbp)
movslq %r8d, %r13
leaq 0x... | /rafat[P]ctsa/src/talg.c |
twacf | int twacf(double *P, int MP, double *Q, int MQ, double *ACF, int MA, double *CVLI, int MXPQ1, double *ALPHA, int MXPQ) {
int ifault, i, k, kc, j, jpk, kcp1mj, j1, kp1, kp2mj, miim1p, imj, mikp, kp1mj;
double epsil2, zero, one, half, two, div;
ifault = 0;
epsil2 = 1.0e-10;
zero = 0.0; half = 0.5, one = 1.0, two = ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %r15d
movq %r8, %r13
movq %rdx, -0x58(%rbp)
movq %rdi, -0x48(%rbp)
movl 0x28(%rbp), %r12d
movl 0x18(%rbp), %ebx
movl %ecx, %r14d
orl %esi, %r14d
shrl $0x1f, %r14d
movl %esi, -0x2c(%rbp)
movl %esi, %edi
movq %rc... | /rafat[P]ctsa/src/talg.c |
artrans | void artrans(int p, double *old, double *new1) {
int j, k;
double a;
double *temp;
temp = (double*)malloc(sizeof(double)* p);
for (j = 0; j < p; ++j) {
new1[j] = tanh(old[j]);
temp[j] = new1[j];
}
for (j = 1; j < p; ++j) {
a = new1[j];
for (k = 0; k < j; ++k) {
temp[k] -= a * new1[j - k - 1];
}
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, -0x30(%rbp)
movslq %edi, %rbx
leaq (,%rbx,8), %rdi
callq 0x6190
movq %rax, %r15
testl %ebx, %ebx
jle 0x3157c
movl -0x30(%rbp), %ebx
xorl %r13d, %r13d
movsd (%r12,%r13,8), %xmm0
callq 0... | /rafat[P]ctsa/src/talg.c |
arinvtrans | void arinvtrans(int p, double *old, double *new1) {
int j, k;
double a;
double *temp;
temp = (double*)malloc(sizeof(double)* p);
for (j = 0; j < p; ++j) {
temp[j] = new1[j] = old[j];
}
for (j = p - 1; j > 0; --j) {
a = new1[j];
for (k = 0; k < j; ++k) {
temp[k] = (new1[k] + a * new1[j - k - 1]) / (1 ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movl %edi, %r13d
movslq %edi, %r15
leaq (,%r15,8), %rdi
callq 0x6190
movq %rax, %r14
testl %r15d, %r15d
jle 0x316d1
movl %r13d, %ecx
xorl %eax, %eax
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, ... | /rafat[P]ctsa/src/talg.c |
gradtrans | void gradtrans(double *raw, int p, int q, int P, int Q,int M, double *A) {
int i, j, v, N;
double w1[100], w2[100], w3[100];
double eps = 1e-03;
N = p + q + P + Q + M;
for (i = 0; i < N; ++i) {
for (j = 0; j < N; ++j) {
if (i == j) {
A[i + j*N] = (double)i;
}
}
}
if (p > 0) {
memcpy(w1, raw, si... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9a8, %rsp # imm = 0x9A8
movl %r9d, %ebx
movq %rdi, -0x40(%rbp)
movq 0x10(%rbp), %r12
movq %rsi, -0x38(%rbp)
movq %rdx, -0x48(%rbp)
leal (%rdx,%rsi), %eax
movq %rcx, -0x50(%rbp)
movq %rax, -0x68(%rbp)
addl %ecx, %eax
mov... | /rafat[P]ctsa/src/talg.c |
archeck | int archeck(int p, double *ar) {
int check, N, i;
double *coeff,*zeror,*zeroi,mod,wmaxv;
int *which,wmax;
N = p + 1;
check = 1;
coeff = (double*)malloc(sizeof(double)*N);
zeror = (double*)malloc(sizeof(double)*p);
zeroi = (double*)malloc(sizeof(double)*p);
which = (int*)malloc(sizeof(int)*N);
coeff[0] = 1.... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %r13d
leal 0x1(%r13), %eax
movl %eax, -0x2c(%rbp)
movslq %eax, %rbx
leaq (,%rbx,8), %rdi
callq 0x6190
movq %rax, %r12
movslq %r13d, %rax
movq %rax, -0x38(%rbp)
leaq (,%rax,8), %r15
movq %r15, %r... | /rafat[P]ctsa/src/talg.c |
invertroot | int invertroot(int q, double *ma) {
int i, index, retval, fail, rcheck, qn, i1, j;
double *temp, *zeror, *zeroi, *xr, *xi,*yr,*yi;
int *ind;
double mod,tempr,tempi;
retval = 0;
index = -1;
for (i = 0; i < q; ++i) {
if (ma[i] != 0.0) {
index = i;
}
}
if (index == -1) {
return retval;
}
temp = (d... | testl %edi, %edi
jle 0x31e2b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r12
movl %edi, %r15d
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
xorl %eax, %eax
xorpd %xmm0, %xmm0
ucomisd (%r12,%rax,8), %xmm0
cmovnel %eax, %r14d
cmovpl %eax, %r14d
incq %ra... | /rafat[P]ctsa/src/talg.c |
supsmu_ | static int supsmu_(int *n, double *x, double *y, double *w, int *iper, double *span, double *alpha, double *smo, double *sc)
{
/* System generated locals */
int sc_dim1, sc_offset, i__1;
double r__1, r__2;
double d__1, d__2;
/* Local variables */
double a, f, h__;
int i__, j;
double sw,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq 0x18(%rbp), %r11
movslq (%rdi), %rbx
movl %ebx, %r15d
movsd -0x8(%rsi,%rbx,8), %xmm1
movsd (%rsi), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x328f0
leal 0x3(%rbx), %eax
testl %ebx, %ebx
cmovnsl %ebx, %eax
sarl $0x2, %eax
leal ... | /rafat[P]ctsa/src/talg.c |
boxcox_eval | void boxcox_eval(double *x, int N, double lambda,double *bxcx) {
double eps;
int i;
eps = macheps() / 744.44;
if (fabs(lambda) < eps) {
for(i = 0; i < N;++i) {
bxcx[i] = log(x[i]);
}
} else {
for(i = 0; i < N;++i) {
bxcx[i] = expm1(lambda * log(x[i])... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movapd %xmm0, -0x30(%rbp)
movl %esi, %r15d
movq %rdi, %r14
xorl %eax, %eax
callq 0x1aaf0
movapd -0x30(%rbp), %xmm2
divsd 0x2158c(%rip), %xmm0 # 0x55168
movapd 0x1f53c(%rip), %xmm1 # 0x53120
andpd %xmm2, %xmm1
u... | /rafat[P]ctsa/src/boxcox.c |
inv_boxcox_eval | double inv_boxcox_eval(double *x,int N, double lambda,double *bxcx) {
int i;
if (lambda == 0) {
for(i = 0; i < N;++i) {
bxcx[i] = exp(x[i]);
}
} else {
for(i = 0; i < N;++i) {
bxcx[i] = exp(log1p(lambda * x[i])/lambda);
}
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x33c9e
jp 0x33c9e
testl %esi, %esi
jle 0x33cdd
movl %esi, %r15d
xorl %r12d, %r12d
movsd (%r14,%r12,8), %xmm0
callq 0x6240
movsd %xmm0, (%rbx,%r12,8)
incq %... | /rafat[P]ctsa/src/boxcox.c |
boxcox_loglik | double boxcox_loglik(double lambda, void *params) {
double loglik,variance,sum;
int N,i;
double *tdata;
double *xpar = (double*) params;
N = (int) xpar[0];
tdata = (double*) malloc(sizeof(double) *N);
sum = 0.0;
for(i = 0; i < N;++i) {
tdata[i] = log(xpar[i+1]);
sum += ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
cvttsd2si (%rdi), %r15d
movsd %xmm0, -0x30(%rbp)
movslq %r15d, %r12
leaq (,%r12,8), %rdi
callq 0x6190
movq %rax, %rbx
testl %r12d, %r12d
jle 0x33db7
movl %r15d, -0x34(%rbp)
movl %r15d, %r12d
xorpd %xmm1, %... | /rafat[P]ctsa/src/boxcox.c |
USPE | void USPE(double *inp,int N,int p, int q, double *phi,double *theta,double *thetac,double *var) {
int K,i,j,l,t,temp,it1;
double wmean,tempd,epsilon;
double *b,*c,*A,*c2,*x,*f,*tau,*T,*h;
int *ipiv,*ipiv2;
K = p + q + 1;
c = (double *) malloc(sizeof(double) * K);
A = (double *) malloc(sizeof(double) * p * p);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, -0x98(%rbp)
movq %r8, -0x48(%rbp)
movl %ecx, %r15d
movl %esi, -0x60(%rbp)
movq %rdi, -0x80(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leal 0x1(%rdx), %r13d
le... | /rafat[P]ctsa/src/boxjenkins.c |
USPE_seasonal | void USPE_seasonal(double *inp,int N,int s,int p, int q, double *phi,double *theta) {
int K,i,j,l,t,temp,it1;
double tempd,epsilon;
double *b,*c,*A,*c2,*x,*f,*tau,*T,*h,*cv;
int *ipiv,*ipiv2;
K = (p + q + 1) * s;
cv = (double *) malloc(sizeof(double) * K);
c = (double *) malloc(sizeof(double) * (p+q+1));
A = ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, -0x48(%rbp)
movl %r8d, %r14d
movl %ecx, %r12d
movl %esi, -0x78(%rbp)
movq %rdi, -0xc8(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leal (%r14,%r12), %eax
movl %eax, -0x50(%rbp)
leal (%r14,%r12), %ebx
incl ... | /rafat[P]ctsa/src/boxjenkins.c |
avaluem | void avaluem(double *w,int N,int p, int q, double *phi,double *theta,int tval,double *a) {
int k,i,t,t2,newl,iter;
double temp;
double *e,*w2,*alpha;
e = (double*) malloc(sizeof(double) * N);
w2 = (double*) malloc(sizeof(double) * tval);
if (p > q) {
k = p;
} else {
k = q;
}
alpha = (double*) malloc(si... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r12
movq %r8, %r13
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, -0x70(%rbp)
movq %rdi, -0x58(%rbp)
movslq 0x10(%rbp), %rbx
movq 0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movslq %esi, %rax
movq %rax, -0x40(%rbp)
l... | /rafat[P]ctsa/src/boxjenkins.c |
avalues | void avalues(double *w,int N,int p, int q, double *phi,double *theta,int s,int ps,int qs,
double *phis, double *thetas,int tval,double *a) {
int k,i,t,t2,newl,iter;
double temp;
double *e,*w2,*alpha,*alpha2;
e = (double*) malloc(sizeof(double) * N);
w2 = (double*) malloc(sizeof(double) * tval);
if (p > q) {... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r14
movq %r8, %r12
movl %ecx, %r15d
movl %edx, -0x30(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdi, -0x70(%rbp)
movslq 0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x30(%rb... | /rafat[P]ctsa/src/boxjenkins.c |
nlalsm | int nlalsm(double *vec,int N,int p,int delta, int q, double *phi,double *theta,
int M,double *thetac,double *var,double eps,double *varcovar,double *residuals) {
int retval,i,j,l,k,t,t2,it,Norig,qd,itmax;
double lam,vmul,e1,di,eps2,stepsize,temp,tau,hmax,suminc,sumb;
double *inp,*b,*at,*at0,*x,*phi0,*theta0,*orig,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %r9, -0x140(%rbp)
movq %r8, -0x60(%rbp)
movl %ecx, %r14d
movq %rdx, -0x48(%rbp)
movl %esi, %ebx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq %rdi, -0x30(%rbp)
jb 0x3559f
sqrtsd %xmm0, %xmm0
... | /rafat[P]ctsa/src/boxjenkins.c |
brent_zero | double brent_zero(custom_funcuni *funcuni, double ai, double bi, double tol, double eps) {
double bz;
double a,b,c,d,e,fa,fb,fc;
double m,s,etol,fd,p,q,r;
int iter;
fd = eps;
a = ai;
b = bi;
c = a;
fa = FUNCUNI_EVAL(funcuni,a);
fb = FUNCUNI_EVAL(funcuni,b);
fc = fa;
e = b - a;
d = e;
if (fabs(fc) < ... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movsd %xmm3, -0x10(%rbp)
movsd %xmm2, -0x28(%rbp)
movaps %xmm1, -0x20(%rbp)
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movsd %xmm0, -0x40(%rbp)
callq *(%rbx)
movaps %xmm0, -0x50(%rbp)
movq 0x8(%rbx), %rdi
movapd -0x20(%rbp), %xmm0
callq *(%rbx)
movapd -0x50(%rbp), %xmm2
... | /rafat[P]ctsa/src/brent.c |
brent_local_min | double brent_local_min(custom_funcuni *funcuni, double a, double b, double t, double eps, double *x) {
double c,d,e,m,p,q,r,tol,t2;
double u,v,w,fu,fv,fw,fx;
double fd;
fd = eps;
c = (3.0 - sqrt(5.0)) / 2.0;
*x = a + c * (b - a);
w = *x; v = w;
e = 0;
fx = FUNCUNI_EVAL(funcuni,*x);
fw = fx; fv = fw;
m ... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movsd %xmm3, -0x48(%rbp)
movsd %xmm2, -0x40(%rbp)
movapd %xmm1, -0x70(%rbp)
movapd %xmm0, %xmm2
movapd %xmm0, -0x30(%rbp)
movq %rdi, %r14
movapd %xmm1, %xmm3
subsd %xmm0, %xmm3
movsd %xmm3, -0x38(%rbp)
movsd 0x1c088(%rip), %xmm0 # 0x55... | /rafat[P]ctsa/src/brent.c |
ichol | int ichol(double *A, int N) {
int sc;
sc = icholu(A,N);
return sc;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl %esi, -0x2c(%rbp)
movslq %esi, %r12
movq %r12, %rdi
imulq %r12, %rdi
shlq $0x3, %rdi
callq 0x6190
movq %rax, -0x38(%rbp)
movq %r14, -0x40(%rbp)
cmpl $0x1, %r12d
je 0x396d1
leal 0x1(%r12), %eax
cltq
le... | /rafat[P]ctsa/src/conjgrad.c |
beta | double beta(double a, double b) {
double oup;
if (a < 0. || b < 0.) {
printf(" The Two Inputs should be nonnegative and real");
exit(1);
}
oup = exp(gamma_log(a) + gamma_log(b) - gamma_log(a+b));
return oup;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
ja 0x3aeda
ucomisd %xmm1, %xmm2
ja 0x3aeda
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
callq 0x3aae2
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x3aae2
addsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x18(%rbp),... | /rafat[P]ctsa/src/dist.c |
erfc1__ | double erfc1__(int ind, double x)
{
/* ----------------------------------------------------------------------- */
/* EVALUATION OF THE COMPLEMENTARY ERROR FUNCTION */
/* ERFC1(IND,X) = ERFC(X) IF IND = 0 */
/* ERFC1(IND,X) = EXP(X*X)*ERFC(X) OTHERWISE */
/* ----------------------... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movapd %xmm0, %xmm6
movapd 0x16c27(%rip), %xmm0 # 0x53120
andpd %xmm6, %xmm0
movsd 0x1793b(%rip), %xmm1 # 0x53e40
ucomisd %xmm0, %xmm1
jae 0x3c544
movsd 0x17945(%rip), %xmm2 # 0x53e58
ucomisd %xmm0, %xmm2
jae 0x3c5ec
movsd 0x1924b(%rip), %xmm2 # 0x55770
ucomisd %x... | /rafat[P]ctsa/src/erfunc.c |
stopcheck_mt | int stopcheck_mt(double fx, int N, double *xc, double *xf, double *jac, double *dx, double fsval, double gtol, double stol, int retval) {
int rcode, i;
double num, den;
double stop0;
double *scheck;
rcode = 0;
if (retval == 3) {
rcode = 4;
return rcode;
}
if (retval == 15) {
rcode = 15;
return rcode;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x3, %r9d
je 0x41eec
cmpl $0xf, %r9d
jne 0x41ef7
movl $0xf, %r14d
jmp 0x4206c
movl $0x4, %r14d
jmp 0x4206c
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r12
movl %edi, %eax
movapd %xmm1, -0x60(%rbp)
movapd %xmm0, -0x70... | /rafat[P]ctsa/src/lnsrchmp.c |
nel_min | int nel_min(custom_function *funcpt,double *xc,int N,double *dx,double fsval,int MAXITER,int *niter,
double eps,double *xf) {
int rcode,NN,i,j,ct,ctl;
int ihi,ilo,L,siter;
double reqmin,rcoeff,ecoeff,ccoeff,fn,del;
double ylo,ynl,temp,ys,yss;
double *P,*Y,*PB,*PS,*PSS,*PM,*PL,*xi,*xmin;
double ysum,yavg,s,dval;... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movsd %xmm1, -0xf0(%rbp)
movl %r8d, -0x84(%rbp)
movq %rcx, -0xd8(%rbp)
movl %edx, %r12d
movq %rsi, -0x90(%rbp)
movq %rdi, -0x60(%rbp)
leal 0x1(%r12), %r15d
movq %r9, -0xa8(%rbp)
movl $0x0, (%r9)
movslq %edx, %rax
movq %ra... | /rafat[P]ctsa/src/neldermead.c |
enorm | double enorm(double *x, int N) {
double enrm;
int i;
double agiant,floatn,one,rdwarf,rgiant,s1,s2,s3,xabs,x1max,x3max,zero;
/*
* C Translation of Fortran Code
* Argonne national laboratory. minpack project. march 1980.
burton s. garbow, kenneth e. hillstrom, jorge j. more
*/
one = 1.0;
zero... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorpd %xmm1, %xmm1
xorpd %xmm10, %xmm10
xorpd %xmm9, %xmm9
testl %esi, %esi
jle 0x44003
cvtsi2sd %esi, %xmm0
movsd 0x11a72(%rip), %xmm2 # 0x55928
divsd %xmm0, %xmm2
movl %esi, %eax
xorpd %xmm3, %xmm3
xorl %ecx, %ecx
movapd 0xf256(%rip), %xmm4 # 0x53120
movsd 0x11a5e(%r... | /rafat[P]ctsa/src/nls.c |
qrfac | void qrfac(double *A, int M, int N, int lda, int pivot, int *ipvt, int lipvt,double *rdiag, double *acnorm,double eps) {
int i,j,jp1,k,kmax,minmn,t;
double ajnorm,epsmch,one,p05,sum,temp,zero,temp2,pmaxval;
double *AT,*wa,*wa2;
/*
* This routine is a C translation of Fortran Code by
* argonne n... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movsd %xmm0, -0x100(%rbp)
movq %r9, -0xb8(%rbp)
movq %rdi, -0x48(%rbp)
movl %r8d, -0x3c(%rbp)
cmpl $0x2, %r8d
jae 0x44691
movq 0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq %e... | /rafat[P]ctsa/src/nls.c |
qrsolv | void qrsolv(double *r,int ldr,int N,int *ipvt,double *diag,double *qtb,double *x,double *sdiag) {
int i,j,jp1,k,kp1,l,nsing,t;
double cos,cotan,p5,p25,qtbpj,sin,sum,tan,temp,zero;
double *wa;
/*
* This routine is a C translation of Fortran Code by
* argonne national laboratory. minpack project. march ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, -0x40(%rbp)
movq %r8, -0x88(%rbp)
movq %rcx, %r14
movl %edx, %ebx
movq %rdi, -0x48(%rbp)
movq 0x18(%rbp), %r13
movq 0x10(%rbp), %r15
movslq %edx, %r12
leaq (,%r12,8), %rdi
callq 0x6190
movq -0x48(%rbp), %r10
mov... | /rafat[P]ctsa/src/nls.c |
fdjac2 | void fdjac2(custom_funcmult *funcmult, double *x, int M, int N, double *fvec, double *fjac, int ldfjac,
double epsfcn,double eps) {
int i,j;
double epsmch,h,temp,zero;
double *wa;
zero = 0.0;
epsmch = eps;
eps = sqrt(pmax(epsfcn,epsmch));
wa = (double*) malloc(sizeof(double) *M);
for(j = 0; j < N;++j) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, -0x40(%rbp)
movq %r8, %r14
movl %ecx, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, -0x50(%rbp)
callq 0x1ab20
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x44be9
sqrtsd %xmm0, %xmm0
jmp 0x4... | /rafat[P]ctsa/src/nls.c |
lmpar | void lmpar(double *r,int ldr,int N,int *ipvt,double *diag,double *qtb,double delta,double *par,double *x,double *sdiag) {
int i,iter,j,jm1,jp1,k,l,nsing;
double dxnorm,dwarf,fp,gnorm,parc,parl,paru,p1,p001,sum,temp,zero;
double *wa1,*wa2;
/*
* This routine is a C translation of Fortran Code by
* argonne ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movsd %xmm0, -0x50(%rbp)
movq %r9, -0x78(%rbp)
movq %r8, %r14
movq %rcx, -0x48(%rbp)
movl %edx, %r12d
movq %rdi, -0x58(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0... | /rafat[P]ctsa/src/nls.c |
lmder | int lmder(custom_funcmult *funcmult, custom_jacobian *jacobian, double *x, int M, int N,
double *fvec,double *fjac,int ldfjac,int maxfev,double *diag,int mode,double factor,int nprint,
double eps,double ftol,double gtol,double xtol,int *nfev,int *njev,int *ipvt, double *qtf) {
int info;
int i,j,l,iter;
double... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movsd %xmm4, -0xc8(%rbp)
movsd %xmm3, -0xa8(%rbp)
movapd %xmm2, -0x150(%rbp)
movsd %xmm1, -0xb8(%rbp)
movsd %xmm0, -0xb0(%rbp)
movq %r9, -0x88(%rbp)
movl %ecx, %r14d
movq %rdx, -0x50(%rbp)
movq %... | /rafat[P]ctsa/src/nls.c |
lmdif | int lmdif(custom_funcmult *funcmult, double *x, int M, int N, double *fvec, double *fjac, int ldfjac,
int maxfev,double *diag,int mode,double factor,int nprint,double eps,double epsfcn,double ftol,double gtol,
double xtol,int *nfev,int *njev,int *ipvt, double *qtf) {
int info;
int i,j,l,iter;
double actred,de... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movsd %xmm5, -0xd0(%rbp)
movsd %xmm4, -0xc0(%rbp)
movapd %xmm3, -0x150(%rbp)
movsd %xmm2, -0x128(%rbp)
movsd %xmm1, -0xa8(%rbp)
movsd %xmm0, -0xc8(%rbp)
movq %r9, -0x60(%rbp)
movq %r8, -0x80(%rbp... | /rafat[P]ctsa/src/nls.c |
normalpdf | double normalpdf(double x, double mu, double sigma) {
double oup,t;
if (sigma < 0.) {
printf("Standard Deviation (Sigma) must be non-negative");
exit(1);
}
t = x - mu;
t = t * t;
oup = exp(-t / ( 2* sigma *sigma)) / ( sqrt(2 * PIVAL) * sigma);
return oup;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
ja 0x46a07
subsd %xmm1, %xmm0
movapd 0xc746(%rip), %xmm1 # 0x53110
xorpd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd %xmm2, -0x8(%rbp)
callq ... | /rafat[P]ctsa/src/pdist.c |
normalcdf | double normalcdf(double x, double mu, double sigma) {
double oup,t;
if (sigma < 0.) {
printf("Standard Deviation (Sigma) must be non-negative");
exit(1);
}
t = (x - mu ) /(sqrt(2.0) * sigma);
oup = 0.5 * (1. + erf(t));
return oup;
} | pushq %rbp
movq %rsp, %rbp
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
ja 0x46a54
subsd %xmm1, %xmm0
mulsd 0xddc7(%rip), %xmm2 # 0x54800
divsd %xmm2, %xmm0
callq 0x3c823
addsd 0xc656(%rip), %xmm0 # 0x530a0
mulsd 0xd3ee(%rip), %xmm0 # 0x53e40
popq %rbp
retq
leaq 0xef95(%rip), %rdi # 0x559f0
xorl %eax, %eax
... | /rafat[P]ctsa/src/pdist.c |
normalinv | double normalinv(double p, double mu, double sigma) {
double oup,t;
if (sigma < 0.) {
printf("Standard Deviation (Sigma) must be non-negative");
exit(1);
}
if (p < 0. || p > 1.0) {
printf("Probablity Values can only take values between 0.0 and 1.0");
exit(1);
}
t = sqrt(2.0) * erfinv(2.0 * p - 1.0);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
ja 0x46ac1
movsd %xmm2, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
ucomisd %xmm0, %xmm3
ja 0x46aca
ucomisd 0xc60a(%rip), %xmm0 # 0x530a0
ja 0x46aca
addsd %xmm0, %xmm0
addsd 0xc634(%rip), %xmm0 # 0x530d8
callq 0x3c848
mulsd 0xdd4f(%rip)... | /rafat[P]ctsa/src/pdist.c |
tpdf | double tpdf(double t, int df) {
double ft,f1,f2,f3;
double pi = 3.1415926535897932384626434;
if (df <= 0) {
printf("Degree Of Freedom should be a positive real integer");
exit(1);
}
f1 = gamma_log((double) (df+1.0)/2.0) - gamma_log((double) (df/2.0));
f2 = exp(f1);
f3 = pow(1.0 + (t*t / (df * 1.0)), - (... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x20(%rbp)
testl %edi, %edi
jle 0x46bbc
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
movsd %xmm0, -0x8(%rbp)
incl %edi
xorps %xmm0, %xmm0
cvtsi2sd %rdi, %xmm0
movsd %xmm0, -0x18(%rbp)
mulsd 0xd326(%rip), %xmm0 # 0x53e40
callq 0x3aae2
movsd %xmm0, -0x10(%rbp)
movs... | /rafat[P]ctsa/src/pdist.c |
tcdf | double tcdf(double t, int df) {
double oup,x,I;
if (df <= 0) {
printf("Degree Of Freedom should be a positive real integer");
exit(1);
}
x = df / (df + t * t);
I = 0.5 * ibeta(x,df / 2.0, 1./2.);
oup = 1. - I;
if ( t < 0.) {
oup = 1. - oup;
}
if ( x == 0.) {
oup = 0.5;
}
return oup;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testl %edi, %edi
jle 0x46c79
cvtsi2sd %edi, %xmm1
movapd %xmm0, %xmm2
movapd %xmm0, -0x20(%rbp)
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movapd %xmm1, %xmm0
divsd %xmm2, %xmm0
movapd %xmm0, -0x10(%rbp)
movsd 0xd232(%rip), %xmm2 # 0x53e40
mulsd %xmm2, %xmm1
callq 0x3b7a8
movs... | /rafat[P]ctsa/src/pdist.c |
tinv_appx | double tinv_appx(double p, int df) {
double t,x,d,g1,g2,g3,g4;
/*
* Abramowitz and Stegun Approximation 26.7.5
*/
if (df <= 0) {
printf("Degree Of Freedom should be a real integer");
exit(1);
}
if (p < 0. || p > 1.0) {
printf("Probablity Values can only take values between 0.0 and 1.0");
exit(1);... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
testl %edi, %edi
jle 0x46f48
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x46f51
ucomisd 0xc3e8(%rip), %xmm0 # 0x530a0
ja 0x46f51
movsd 0xc3da(%rip), %xmm1 # 0x530a0
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
leaq 0xec96(%rip), %rcx # 0x55970... | /rafat[P]ctsa/src/pdist.c |
tinv | double tinv(double p, int df) {
double t,q,pmin,x,y,d2,sign;
if (df <= 0) {
printf("Degree Of Freedom should be a positive real integer");
exit(1);
}
if (p < 0. || p > 1.0) {
printf("Probablity Values can only take values between 0.0 and 1.0");
exit(1);
}
q = 1. - p;
if ( p <= q ) {
pmin = 2.0 ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testl %edi, %edi
jle 0x47082
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x4708b
ucomisd 0xc111(%rip), %xmm0 # 0x530a0
ja 0x4708b
movsd 0xc103(%rip), %xmm1 # 0x530a0
movapd %xmm0, %xmm2
cmpltpd %xmm1, %xmm2
xorpd %xmm1, %xmm1
cmpltpd %xmm0, %xmm1
andpd %xmm2, %xmm1
mov... | /rafat[P]ctsa/src/pdist.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.