/*f3*/
static double f3(double *tab,int n)
{
double s3=tab[0];
double S=tab[1];
double K=tab[2];
double T=tab[3];
double r=tab[4];
double divid=tab[5];
double sigma=tab[6];
double s1=tab[7];
double s2=tab[8];
double d=ap_carr_D(divid,T,n);
double epsilon=ap_carr_epsilon(r,divid,sigma,T,n);
double gamma_carr=ap_carr_gamma(r,divid,sigma);
double delta=ap_carr_delta(T,n);
double R1=ap_carr_R(r,T,n);
double p1=ap_carr_p(r,divid,sigma,T,n);
double p_1=ap_carr_phat(r,divid,sigma,T,n);
double q1=ap_carr_q(r,divid,sigma,T,n);
double q_1=ap_carr_qhat(r,divid,sigma,T,n);
double s_1[3];
s_1[0]=K;
s_1[1]=s1;
s_1[2]=s2;
return K*pow_int(d*p_1,3)*(1+3*q_1+6*SQR(q_1))-K*pow_int(R1*p1,3)*(1+3*q1+6*SQR(q1))-ap_carr_a(1,2,3,S,K,T,r,divid,sigma,s_1,K)-delta*(p1*K*R1*r-p_1*d*divid*s3)*pow(K/s3,gamma_carr+epsilon);
}
/*b*/
static double ap_carr_b(int i,int n,double S,double K,double T,double r,double divid,double sigma,double s[10])
{
int j,k,l;
double S1,S2,S3;
double d=ap_carr_D(divid,T,n);
double epsilon=ap_carr_epsilon(r,divid,sigma,T,n);
double gamma_carr=ap_carr_gamma(r,divid,sigma);
double delta=ap_carr_delta(T,n);
double R1=ap_carr_R(r,T,n);
double q1=ap_carr_q(r,divid,sigma,T,n);
double p1=ap_carr_p(r,divid,sigma,T,n);
double q_1=ap_carr_qhat(r,divid,sigma,T,n);
double p_1=ap_carr_phat(r,divid,sigma,T,n);
S1=0.;
for(j=1;j<=n-i+1;j++)
{
S2=0.;
for(k=0;k<=j-1;k++)
{
S3=0.;
for(l=0;l<=j-k-1;l++)
{
S3+=Combi(j-1+l,j-1)*(pow_int(q1*R1,j)*pow_int(p1,k+l)*K*r-pow_int(q_1*d,j)*pow_int(p_1,k+l)*s[n-j+1]*divid)*delta;
}
S2+=(pow_int(2*epsilon*log(S/s[n-j+1]),k)/Factor(k))*S3;
}
S1+=pow(S/s[n-j+1],gamma_carr-epsilon)*S2;
}
return S1;
}
int pow_int(int x, int n) {
if (n == 0) return 1;
if (n == 1) return x;
if (n % 2 == 0) {
int tmp = pow_int(x, n/2);
return tmp*tmp;
}
return x * pow_int(x, n-1);
}
static void
compute_XYZVW(const double m1, const double tV, const double k, const double Roa, const double n, const double a,
const double e, const double m2, const double xhat[3], const double yhat[3],
const double zhat[3], const double spin[3],
double *X, double *Y, double *Z, double *V, double *W) {
double e2 = e*e;
double e4 = e2*e2;
double e6 = e4*e2;
double Roa5 = pow_int(Roa, 5);
double aoR8 = pow_int(Roa, -8);
double mu = m1*m2/(m1+m2);
double tF = tV/9.0*aoR8*m1*m1/(m1+m2)/m2*pow_int(1.0 + 2.0*k, -2);
double Ox = dot(spin, xhat);
double Oy = dot(spin, yhat);
double Oz = dot(spin, zhat);
*X = -m2*k*Roa5/(mu*n)*Oz*Ox/pow_int(1-e2, 2) - Oy/(2*n*tF)*(1.0 + (9.0/2.0)*e2 + (5.0/8.0)*e4)/pow_int(1-e2, 5);
*Y = -m2*k*Roa5/(mu*n)*Oz*Oy/pow_int(1-e2, 2) + Ox/(2*n*tF)*(1.0 + (3.0/2.0)*e2 + (1.0/8.0)*e4)/pow_int(1-e2, 5);
*Z = m2*k*Roa5/(mu*n)*((2*Oz*Oz - Oy*Oy - Ox*Ox)/(2.0*pow_int(1-e2,2)) + 15.0*m2/pow_int(a,3)*(1.0 + (3.0/2.0)*e2 + (1.0/8.0)*e4)/pow_int(1-e2,5));
*V = 9.0/tF*((1.0 + (15.0/4.0)*e2 + (15.0/8.0)*e4 + (5.0/64.0)*e6)/sqrt(pow_int(1-e2,13)) - 11.0*Oz/(18.0*n)*(1.0 + (3.0/2.0)*e2 + (1.0/8.0)*e4)/pow_int(1-e2, 5));
*W = 1.0/tF*((1.0 + (15.0/2.0)*e2 + (45.0/8.0)*e4 + (5.0/16.0)*e6)/sqrt(pow_int(1-e2,13)) - Oz/n*(1.0 + 3.0*e2 + (3.0/8.0)*e4)/pow_int(1-e2, 5));
}
void polynomialBasis::evaluateMonomials(double u, double v, double w,
double p[]) const
{
for(int j = 0; j < monomials.size1(); ++j) {
p[j] = 1.;
switch(dimension) {
case 3: p[j] *= pow_int(w, monomials(j, 2));
case 2: p[j] *= pow_int(v, monomials(j, 1));
case 1: p[j] *= pow_int(u, monomials(j, 0));
default: break;
}
}
}
/*Puteuro_n*/
static double Put_euro_n(double S, double K, double T, double r, double divid, double sigma,int n)
{
double d=ap_carr_D(divid,T,n);
double epsilon=ap_carr_epsilon(r,divid,sigma,T,n);
double gamma_carr=ap_carr_gamma(r,divid,sigma);
double R1=ap_carr_R(r,T,n);
double q1=ap_carr_q(r,divid,sigma,T,n);
double p1=ap_carr_p(r,divid,sigma,T,n);
double q_1=ap_carr_qhat(r,divid,sigma,T,n);
double p_1=ap_carr_phat(r,divid,sigma,T,n);
double S1,S2;
int k,l;
if(S<=K)
{
return K*pow_int(R1,n)-S*pow_int(d,n)+Call_euro_n(S,K,T,r,divid,sigma,n);
} else {
S1=0;
for (k=0;k<=n-1;k++) {
S2=0;
for(l=0;l<=n-k-1;l++){
S2+=Combi(n-1+l,n-1)*(K*pow_int(R1,n)*pow_int(q1,n)*pow_int(p1,k+l)-K*pow_int(d,n)*pow_int(q_1,n)*pow_int(p_1,k+l));
}
S1+=(pow_int(2*epsilon*log(S/K),k)/Factor(k))*S2;
}
return pow(S/K,gamma_carr-epsilon)*S1;
}
}
format_file_size_short::format_file_size_short(t_uint64 size) {
t_uint64 scale = 1;
const char * unit = "B";
const char * const unitTable[] = {"B","KB","MB","GB","TB"};
for(t_size walk = 1; walk < PFC_TABSIZE(unitTable); ++walk) {
t_uint64 next = scale * 1024;
if (size < next) break;
scale = next; unit = unitTable[walk];
}
*this << ( size / scale );
if (scale > 1 && length() < 3) {
t_size digits = 3 - length();
const t_uint64 mask = pow_int(10,digits);
t_uint64 remaining = ( (size * mask / scale) % mask );
while(digits > 0 && (remaining % 10) == 0) {
remaining /= 10; --digits;
}
if (digits > 0) {
*this << "." << format_uint(remaining, (t_uint32)digits);
}
}
*this << " " << unit;
m_scale = scale;
}
void get_probabilities(FILE *input_file, unsigned long n_symbols, unsigned long *probs)
{
unsigned long current_symbol;
unsigned char *buffer, *buffer_point;
unsigned int bytes_read, i, j;
unsigned int length = n_symbols / 256;
buffer = malloc(length * READ_SIZE);
// Initialize the probabilities vector to 0
for (i = 0; i < n_symbols; i++)
probs[i] = 0;
// Get the probabilities of each symbol in the file
while(!feof(input_file)) {
bytes_read = fread(buffer, length, READ_SIZE, input_file);
buffer_point = buffer;
for (; bytes_read > 0; bytes_read--) {
current_symbol = 0;
for (j = 0; j < length; j++) {
current_symbol += *buffer_point * pow_int(256, j);
buffer_point++;
}
probs[current_symbol]++;
}
}
free(buffer);
}
static double pow_int(const double x, const int n) {
if (n < 0) {
return pow_int(1.0/x, -n);
} else if (n == 0) {
if (x == 0.0) {
return 0.0/0.0;
} else {
return 1.0;
}
} else if (n == 1) {
return x;
} else if (n % 2 == 0) {
double sqrt_xn = pow_int(x, n/2);
return sqrt_xn*sqrt_xn;
} else {
double sqrt_xn = pow_int(x, (n-1)/2);
return x * sqrt_xn * sqrt_xn;
}
}
arithmtype Pow(void)
{
arithmtype Q,Res = Term();
while(*Expr=='^')
{
if ( ErrorDesc )
break;
Expr++;
Q = Pow();
Res = pow_int(Res,Q);
}
return Res;
}
int bytestoint (char *s) {
int l=strlen(s);
int buf=0;
int pos=0;
int rezult=0;
unsigned char utemp=0;
while(l!=0) {
utemp=s[l-1];
buf=utemp*pow_int(256, pos);
rezult+=buf;
l--;
pos++;
}
return rezult;
}
/*
* Simulation factor defpending on the 'simu_speed_flag' flag
*/
double get_simu_speed_factor(int simu_speed_flag)
{
if (simu_speed_flag < 0)
{
return pow_int(2.0,simu_speed_flag);
}
else if (simu_speed_flag > 0)
{
return simu_speed_flag + 1.0;
}
else
{
return 1.0;
}
}
// the haar wavelet decomposition
void dwt_haar(int16_t *d, int16_t dlenpwr, int16_t depth){
// dlenpwr -> 2^dlenpwr is the length of the data array
// depth -> the depth of the analysis to be performed
for(int i = (dlenpwr-1); i > (dlenpwr - 1 - depth); i-- ){
// the i_ubnd of the current level of data we are looking at
// also, it is the appropriate level because we are searching 2*j and 2*j+1
int16_t i_ubnd = pow_int(2,i);
// decomp
// a1' = ((a1+a2)*10000)/sqrt(2)
// a2' = ((a1-a2)*10000)/sqrt(2)
haar_add_sub_adjacent(d, i_ubnd,10000,SQRT_TWO_4P);
// reorder the elements toward the wavelet transform
decomp_haar_order(d, 0, 2*i_ubnd-1);
}
}
int aux(int x, int alpha, int beta) {
if (x == 0) return 1;
int two_alpha = 1 << alpha;
if (two_alpha > x) return 0;
if (cache[x][alpha][beta] != -1)
return cache[x][alpha][beta];
int res = aux(x, alpha+1, beta);
if (res < 2)
for (int i = 0; i <= beta; i++) {
int s = two_alpha * pow_int(3, i);
if (s > x) break;
res += aux(x - s, alpha + 1, i - 1);
if (res >= 2) break;
}
res = res > 2 ? 2: res;
cache[x][alpha][beta] = res;
return res;
}
// the haar wavelet reconstruction
void idwt_haar(int16_t *d, int16_t dlenpwr, int16_t depth){
// dlenpwr -> 2^dlenpwr is the length of the data array
// depth -> the depth of the analysis to be performed
for(int16_t i = (dlenpwr - depth) ; i < (dlenpwr); i++ ){
// the i_ubnd of the current level of data we are looking at
// also, it is the appropriate level because we are searching 2*j and 2*j+1
int16_t i_ubnd = pow_int(2,i);
// reorder the elements away from the wavelet transform
recon_haar_order(d, 0, 2*i_ubnd-1);
// we have 2*10000 instead of 10000 because the addition and subtraction operation
// in the reconstruction phase has the form
// recon
// a1'' = ((((a1+a2)*10000)/sqrt(2))*sqrt(2))/(2*10000) = (2*a1 + a2 - a2)/2 = a1
// a2'' = ((((a1+a2)*10000)/sqrt(2))*sqrt(2))/(2*10000) = (a1 - a1 + 2*a2)/2 = a2
haar_add_sub_adjacent(d, i_ubnd, SQRT_TWO_4P,2*10000);
}
}
void polynomialBasis::df(double u, double v, double w, int i, double grad[3]) const
{
if(i < 0 || i >= coefficients.size1()){
Msg::Error("Node out of range for polynomial basis gradient");
return;
}
switch(monomials.size2()) {
case 1:
grad[0] = 0;
grad[1] = 0;
grad[2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 0)
grad[0] += coefficients(i, j) *
pow_int(u, (monomials(j, 0) - 1)) * monomials(j, 0);
}
break;
case 2:
grad[0] = 0;
grad[1] = 0;
grad[2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 0)
grad[0] += coefficients(i, j) *
pow_int(u, (monomials(j, 0) - 1)) * monomials(j, 0) *
pow_int(v, monomials(j, 1));
if(monomials(j, 1) > 0)
grad[1] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, (monomials(j, 1) - 1)) * monomials(j, 1);
}
break;
case 3:
grad[0] = 0;
grad[1] = 0;
grad[2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 0)
grad[0] += coefficients(i, j) *
pow_int(u, (monomials(j, 0) - 1)) * monomials(j, 0) *
pow_int(v, monomials(j, 1)) *
pow_int(w, monomials(j, 2));
if(monomials(j, 1) > 0)
grad[1] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, (monomials(j, 1) - 1)) * monomials(j, 1) *
pow_int(w, monomials(j, 2));
if(monomials(j, 2) > 0)
grad[2] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1)) *
pow_int(w, (monomials(j, 2) - 1)) * monomials(j, 2);
}
break;
}
}
int decode(FILE *input_file, unsigned long file_size, char *input_file_name, FILE *output_file)
{
unsigned long i, j, k;
char filetype[] = ".huf1.0";
unsigned char *bufferheader;
bufferheader = malloc(7);
fread(bufferheader ,7 ,1 , input_file);
unsigned char filled;
fread(&filled, 1, 1, input_file);
for (i = 0; i < 4; i++) {
if (filetype[i] != bufferheader[i])
break;
}
if (i != 4) {
printf("File %s is not a valid huffman file\n", input_file_name);
return 2;
}
printf("- Huffman file %s is version %c%c%c\n", input_file_name, bufferheader[4], bufferheader[5], bufferheader[6]);
unsigned char length;
fread(&length, 1, 1, input_file);
printf("- Length = %u\n", length);
unsigned long n_symbols = pow_int(2, 8 * length);
unsigned long tree[(n_symbols - 1) * 2];
printf("- Number of symbols: %lu\n", n_symbols);
fread(tree, (n_symbols - 1) * 2, sizeof(unsigned long), input_file);
code codefinal[n_symbols];
create_huff_code(tree, n_symbols, codefinal);
unsigned char buffer = 0;
unsigned char binarybuffer[n_symbols*2];
int binarybuffersize = 0;
i = (unsigned long) ftell(input_file);
while (!feof(input_file)) {
while (binarybuffersize < n_symbols && !feof(input_file)) {
fread(&buffer, 1, 1, input_file);
for (j = 0; j < 8 * length; j++) {
binarybuffer[binarybuffersize - j + 8 * length - 1] = buffer % 2;
buffer = buffer/2;
}
binarybuffersize += 8 * length;
}
if (feof(input_file))
binarybuffersize -= filled + length * 8;
if (binarybuffersize > 0) {
for (j = 0; j < n_symbols; j++) {
for (k = 0; k < codefinal[j].length; k++) {
if (codefinal[j].value[k] != binarybuffer[k])
break;
}
if (codefinal[j].length == k) {
fwrite(&j,length,1,output_file);
for (k = 0; k < n_symbols * 2 - codefinal[j].length; k++)
binarybuffer[k] = binarybuffer[k+codefinal[j].length];
binarybuffersize -= codefinal[j].length;
break;
}
}
}
}
while (binarybuffersize > 0) {
for (j = 0; j < n_symbols; j++) {
for (k = 0; k < codefinal[j].length; k++){ // <--
if (codefinal[j].value[k] != binarybuffer[k])
break;
}
if (codefinal[j].length == k) {
fwrite(&j,length,1,output_file);
for (k = 0; k < n_symbols * 2 - codefinal[j].length; k++)
binarybuffer[k] = binarybuffer[k+codefinal[j].length];
binarybuffersize -= codefinal[j].length;
break;
}
}
}
free(bufferheader);
return 0;
}
int encode(FILE *input_file, unsigned long file_size, FILE *output_file, unsigned int length)
{
unsigned long i, j, n_symbols, current_symbol, tmp;
unsigned long *probs;
unsigned char *buffer;
code *codefinal;
n_symbols = pow_int(2, 8 * length);
buffer = malloc(length * READ_SIZE);
probs = malloc(pow_int(2, 8 * length) * sizeof(unsigned long));
get_probabilities(input_file, n_symbols, probs);
unsigned long tree[(n_symbols - 1) * 2];
create_tree(probs, n_symbols, tree);
// Show packed tree
for (i = 0; i < (n_symbols - 1); i++)
printf("(%lu, %lu) ", tree[i * 2], tree[i * 2 + 1]);
printf("\n");
codefinal = malloc(n_symbols * 2 * sizeof(code));
create_huff_code(tree, n_symbols, codefinal);
fseek(input_file, 0L, SEEK_SET);
unsigned char binarybuffer[n_symbols];
unsigned long binarybuffersize = 0;
unsigned char *outbuffer;
outbuffer = malloc(length);
//Headers of file
//X will be the number of bits added to create the last byte
char filetype[] = ".huf1.0X";
for (i = 0; i < 8; i++)
fwrite(&filetype[i], 1, 1, output_file);
fwrite(&length, 1, 1, output_file);
for (i = 0; i < (n_symbols - 1) * 2; i++)
fwrite(&tree[i], sizeof(unsigned long), 1, output_file);
for (i = 0; i < file_size/length; i++) {
fread(buffer, length, 1, input_file);
current_symbol = 0;
for (j = 0; j < length; j++)
current_symbol += buffer[j]*pow_int(2,8*(length - 1 - j));
for (j = 0; j < codefinal[current_symbol].length; j++)
binarybuffer[binarybuffersize+j] = codefinal[current_symbol].value[j];
binarybuffersize += codefinal[current_symbol].length;
while (binarybuffersize >= length*8){
*outbuffer = 0;
for (j = 0; j < length*8; j++)
*outbuffer += binarybuffer[length*8 - 1 - j] * pow_int(2,j);
fwrite(outbuffer ,length ,1 ,output_file);
for (j = 0; j < binarybuffersize - length*8; j++)
binarybuffer[j] = binarybuffer[j+length*8];
binarybuffersize -= length*8;
}
}
unsigned char filled = length*8 - binarybuffersize;
*outbuffer = 0;
for (j = 0; j < length*8; j++)
*outbuffer += binarybuffer[length*8 - 1 - j] * pow_int(2,j);
fwrite(outbuffer ,length ,1 ,output_file);
fseek(output_file, 7 * length, SEEK_SET);
fwrite(&filled, 1, 1, output_file);
free(probs);
free(outbuffer);
return 0;
}
void polynomialBasis::df(double u, double v, double w, double grads[][3]) const
{
switch(monomials.size2()) {
case 1:
for(int i = 0; i < coefficients.size1(); i++) {
grads[i][0] = 0;
grads[i][1] = 0;
grads[i][2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 0)
grads[i][0] += coefficients(i, j) *
pow_int(u, (monomials(j, 0) - 1)) * monomials(j, 0);
}
}
break;
case 2:
for(int i = 0; i < coefficients.size1(); i++) {
grads[i][0] = 0;
grads[i][1] = 0;
grads[i][2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 0)
grads[i][0] += coefficients(i, j) *
pow_int(u, (monomials(j, 0) - 1)) * monomials(j, 0) *
pow_int(v, monomials(j, 1));
if(monomials(j, 1) > 0)
grads[i][1] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, (monomials(j, 1) - 1)) * monomials(j, 1);
}
}
break;
case 3:
for(int i = 0; i < coefficients.size1(); i++) {
grads[i][0] = 0;
grads[i][1] = 0;
grads[i][2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 0)
grads[i][0] += coefficients(i, j) *
pow_int(u, (monomials(j, 0) - 1)) * monomials(j, 0) *
pow_int(v, monomials(j, 1)) *
pow_int(w, monomials(j, 2));
if(monomials(j, 1) > 0)
grads[i][1] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, (monomials(j, 1) - 1)) * monomials(j, 1) *
pow_int(w, monomials(j, 2));
if(monomials(j, 2) > 0)
grads[i][2] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1)) *
pow_int(w, (monomials(j, 2) - 1)) * monomials(j, 2);
}
}
break;
}
}
/*v*/
static double ap_carr_v(int i,int n,double s,double K,double T,double r,double divid)
{
return K*pow_int(ap_carr_R(r,T,n),n-i+1)-s*pow_int(ap_carr_D(divid,T,n),n-i+1);
}
int main(){
unsigned long int p,q,n,fi_n,e,d;
char mensagem[10] = {};
//try long int
unsigned long int mensagem_c[10] = {0};
char mensagem_d[10] = {};
srand(time(NULL));
//cria_num_primos(&p,&q);
//teste
p = 17;
q = 19;
//printf("numero primos %ld %ld\n",p,q);
n = p * q;
printf("N %ld",n);
//printf("n = p x q = %ld\n",n);
fi_n = (p - 1) * (q - 1);
//printf("fi(n) = (p - 1) x (q - 1) = %ld\n",fi_n);
e = escolha_e(fi_n);
e = 5;
printf("e: %ld\n",e);
d = calculo_d(fi_n,e);
d = 173;
printf("d: %ld\n",d);
printf("Chaves\n");
printf("Publica: { %ld , %ld }\n",e,n);
printf("Privada: { %ld , %ld }\n",d,n);
printf("------------------------------\n");
printf(" Digite sua mensagem: \n");
scanf("%s",mensagem);
int i=0;
unsigned long int c_int;
char c;
//printf("pow_int 2^3 %ld\n",pow_int(2,3));
//for(i=0;i<strlen(mensagem);i++){
for(i=0;i<10;i++){
printf("%c ",mensagem[i]);
c_int = mensagem[i];
printf(" : %ld n: %ld\n",c_int,n);
mensagem_c[i] = pow_int(c_int,e) % n ;
printf("%ld\n",mensagem_c[i]);
printf("fu %d",pow_int_mod(c_int,e,n));
}
//puts(mensagem);
for(i=0;i<10;i++){
//c_int = pow_int(mensagem[i],d) % n;
c_int = pow_int_mod(mensagem_c[i],d, n);
// c_int = mensagem[i] * mensagem[i]) % n;
// c_int = c_int *mensagem[i]) % n;
printf("c_int %ld\n",c_int);
c = (char)c_int;
printf("%c \n",c);
}
return 0;
}
void operator()(const Uint node_idx)
{
const Uint nb_moments = 2*m_nb_phases;
m_rhs.setZero();
for(Uint alpha = 0; alpha != m_nb_phases; ++alpha) // For all phases
{
const Real n_alpha = (*m_concentration_fields[alpha])[node_idx][0];
const Real vol_alpha = (*m_weighted_volume_fields[alpha])[node_idx][0] / n_alpha;
for(int ki = 0; ki != nb_moments; ++ki) // For all moments
{
const Real k = static_cast<Real>(ki);
m_mat(ki, alpha) = (1.-k) * pow_int(vol_alpha, ki);
m_mat(ki, alpha+m_nb_phases) = k * pow_int(vol_alpha, ki-1);
}
for(Uint gamma = 0; gamma != m_nb_phases; ++gamma)
{
const Real n_gamma = (*m_concentration_fields[gamma])[node_idx][0];
const Real vol_gamma = (*m_weighted_volume_fields[gamma])[node_idx][0] / n_gamma;
const Real beta = m_beta->apply(node_idx, alpha, gamma);
// std::cout << "computing for vol_alpha " << vol_alpha << ", vol_gamma: " << vol_gamma << ", n_alpha " << n_alpha << ", n_gamma " << n_gamma << ", beta " << beta << std::endl;
// std::cout << "collision value: " << (beta*n_alpha*n_gamma) << std::endl;
for(int k = 0; k != nb_moments; ++k ) // For all moments
{
m_rhs[k] += (0.5*pow_int(vol_alpha + vol_gamma, k ) - pow_int(vol_alpha, k )) * (beta*n_alpha*n_gamma);
}
if(is_not_null(m_collision_rate_field))
{
const Uint var_idx = alpha*m_nb_phases + gamma;
cf3_assert(var_idx < m_collision_rate_field->row_size());
(*m_collision_rate_field)[node_idx][var_idx] = n_alpha*n_gamma*beta;
}
}
}
Eigen::Map<RealVector> x(&(*m_source_field)[node_idx][0], nb_moments);
// Check for NaN
for(Uint k = 0; k != nb_moments; ++k)
{
if(!std::isfinite(m_rhs[k]))
{
x.setZero();
return;
}
}
Eigen::FullPivLU<RealMatrix> lu(m_mat);
if(!lu.isInvertible())
{
Eigen::JacobiSVD<RealMatrix> svd(m_mat, Eigen::ComputeThinU | Eigen::ComputeThinV);
x = svd.solve(m_rhs);
}
else
{
x = lu.solve(m_rhs);
}
// std::cout << "matrix:\n" << m_mat << std::endl;
// std::cout << "rhs: " << m_rhs.transpose() << std::endl;
// std::cout << "x: " << x.transpose() << std::endl;
}
void polynomialBasis::dddf(double u, double v, double w,
double third[][3][3][3]) const
{
switch(monomials.size2()) {
case 1:
for(int i = 0; i < coefficients.size1(); i++) {
for(int p = 0; p < 3; p++)
for(int q = 0; q < 3; q++)
for(int r = 0; r < 3; r++) third[i][p][q][r] = 0.;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 2) // third derivative !=0
third[i][0][0][0] +=
coefficients(i, j) * pow_int(u, (monomials(j, 0) - 3)) *
monomials(j, 0) * (monomials(j, 0) - 1) * (monomials(j, 0) - 2);
}
}
break;
case 2:
for(int i = 0; i < coefficients.size1(); i++) {
for(int p = 0; p < 3; p++)
for(int q = 0; q < 3; q++)
for(int r = 0; r < 3; r++) third[i][p][q][r] = 0.;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 2) // second derivative !=0
third[i][0][0][0] +=
coefficients(i, j) * pow_int(u, (monomials(j, 0) - 3)) *
monomials(j, 0) * (monomials(j, 0) - 1) * (monomials(j, 0) - 2) *
pow_int(v, monomials(j, 1));
if((monomials(j, 0) > 1) && (monomials(j, 1) > 0))
third[i][0][0][1] +=
coefficients(i, j) * pow_int(u, monomials(j, 0) - 2) *
monomials(j, 0) * (monomials(j, 0) - 1) *
pow_int(v, monomials(j, 1) - 1) * monomials(j, 1);
if((monomials(j, 0) > 0) && (monomials(j, 1) > 1))
third[i][0][1][1] +=
coefficients(i, j) * pow_int(u, monomials(j, 0) - 1) *
monomials(j, 0) * pow_int(v, monomials(j, 1) - 2) *
monomials(j, 1) * (monomials(j, 1) - 1);
if(monomials(j, 1) > 2)
third[i][1][1][1] +=
coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1) - 3) * monomials(j, 1) *
(monomials(j, 1) - 1) * (monomials(j, 1) - 2);
}
third[i][0][1][0] = third[i][0][0][1];
third[i][1][0][0] = third[i][0][0][1];
third[i][1][0][1] = third[i][0][1][1];
third[i][1][1][0] = third[i][0][1][1];
}
break;
case 3:
for(int i = 0; i < coefficients.size1(); i++) {
for(int p = 0; p < 3; p++)
for(int q = 0; q < 3; q++)
for(int r = 0; r < 3; r++) third[i][p][q][r] = 0.;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 2) // second derivative !=0
third[i][0][0][0] +=
coefficients(i, j) * pow_int(u, (monomials(j, 0) - 3)) *
monomials(j, 0) * (monomials(j, 0) - 1) * (monomials(j, 0) - 2) *
pow_int(v, monomials(j, 1)) * pow_int(w, monomials(j, 2));
if((monomials(j, 0) > 1) && (monomials(j, 1) > 0))
third[i][0][0][1] += coefficients(i, j) *
pow_int(u, monomials(j, 0) - 2) *
monomials(j, 0) * (monomials(j, 0) - 1) *
pow_int(v, monomials(j, 1) - 1) *
monomials(j, 1) * pow_int(w, monomials(j, 2));
if((monomials(j, 0) > 1) && (monomials(j, 2) > 0))
third[i][0][0][2] +=
coefficients(i, j) * pow_int(u, monomials(j, 0) - 2) *
monomials(j, 0) * (monomials(j, 0) - 1) *
pow_int(v, monomials(j, 1)) * pow_int(w, monomials(j, 2) - 1) *
monomials(j, 2);
if((monomials(j, 0) > 0) && (monomials(j, 1) > 1))
third[i][0][1][1] +=
coefficients(i, j) * pow_int(u, monomials(j, 0) - 1) *
monomials(j, 0) * pow_int(v, monomials(j, 1) - 2) *
monomials(j, 1) * (monomials(j, 1) - 1) *
pow_int(w, monomials(j, 2));
if((monomials(j, 0) > 0) && (monomials(j, 1) > 0) &&
(monomials(j, 2) > 0))
third[i][0][1][2] +=
coefficients(i, j) * pow_int(u, monomials(j, 0) - 1) *
monomials(j, 0) * pow_int(v, monomials(j, 1) - 1) *
monomials(j, 1) * pow_int(w, monomials(j, 2) - 1) * monomials(j, 2);
if((monomials(j, 0) > 0) && (monomials(j, 2) > 1))
third[i][0][2][2] += coefficients(i, j) *
pow_int(u, monomials(j, 0) - 1) *
monomials(j, 0) * pow_int(v, monomials(j, 1)) *
pow_int(w, monomials(j, 2) - 2) *
monomials(j, 2) * (monomials(j, 2) - 1);
if((monomials(j, 1) > 2))
third[i][1][1][1] +=
coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1) - 3) * monomials(j, 1) *
(monomials(j, 1) - 1) * (monomials(j, 1) - 2) *
pow_int(w, monomials(j, 2));
if((monomials(j, 1) > 1) && (monomials(j, 2) > 0))
third[i][1][1][2] +=
coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1) - 2) * monomials(j, 1) *
(monomials(j, 1) - 1) * pow_int(w, monomials(j, 2) - 1) *
monomials(j, 2);
if((monomials(j, 1) > 0) && (monomials(j, 2) > 1))
third[i][1][2][2] +=
coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1) - 1) * monomials(j, 1) *
pow_int(w, monomials(j, 2) - 2) * monomials(j, 2) *
(monomials(j, 2) - 1);
if((monomials(j, 2) > 2))
third[i][2][2][2] +=
coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1)) * pow_int(w, monomials(j, 2) - 3) *
monomials(j, 2) * (monomials(j, 2) - 1) * (monomials(j, 2) - 2);
}
third[i][0][1][0] = third[i][0][0][1];
third[i][1][0][0] = third[i][0][0][1];
third[i][2][0][0] = third[i][0][0][2];
third[i][0][2][0] = third[i][0][0][2];
third[i][1][0][1] = third[i][0][1][1];
third[i][1][1][0] = third[i][0][1][1];
third[i][0][2][1] = third[i][0][1][2];
third[i][1][0][2] = third[i][0][1][2];
third[i][1][2][0] = third[i][0][1][2];
third[i][2][1][0] = third[i][0][1][2];
third[i][2][0][1] = third[i][0][1][2];
third[i][2][2][0] = third[i][0][2][2];
third[i][2][0][2] = third[i][0][2][2];
third[i][1][2][1] = third[i][1][1][2];
third[i][2][1][1] = third[i][1][1][2];
third[i][2][2][1] = third[i][1][2][2];
third[i][2][1][2] = third[i][1][2][2];
}
break;
}
}
int
main (void)
{
int rnd;
mpfr_prec_t p;
tests_start_mpfr ();
p = (randlimb () % 200) + MPFR_PREC_MIN;
RND_LOOP (rnd)
{
test2a (mpfr_round, "mpfr_round", p);
test2a (mpfr_ceil, "mpfr_ceil", p);
test2a (mpfr_floor, "mpfr_floor", p);
test2a (mpfr_trunc, "mpfr_trunc", p);
test2ui (mpfr_add_ui, "mpfr_add_ui", p, (mpfr_rnd_t) rnd);
test2ui (mpfr_div_2exp, "mpfr_div_2exp", p, (mpfr_rnd_t) rnd);
test2ui (mpfr_div_ui, "mpfr_div_ui", p, (mpfr_rnd_t) rnd);
test2ui (mpfr_mul_2exp, "mpfr_mul_2exp", p, (mpfr_rnd_t) rnd);
test2ui (mpfr_mul_ui, "mpfr_mul_ui", p, (mpfr_rnd_t) rnd);
test2ui (mpfr_pow_ui, "mpfr_pow_ui", p, (mpfr_rnd_t) rnd);
test2ui (mpfr_sub_ui, "mpfr_sub_ui", p, (mpfr_rnd_t) rnd);
testui2 (mpfr_ui_div, "mpfr_ui_div", p, (mpfr_rnd_t) rnd);
testui2 (mpfr_ui_sub, "mpfr_ui_sub", p, (mpfr_rnd_t) rnd);
testui2 (mpfr_ui_pow, "mpfr_ui_pow", p, (mpfr_rnd_t) rnd);
test2 (mpfr_sqr, "mpfr_sqr", p, (mpfr_rnd_t) rnd);
test2 (mpfr_sqrt, "mpfr_sqrt", p, (mpfr_rnd_t) rnd);
test2 (mpfr_abs, "mpfr_abs", p, (mpfr_rnd_t) rnd);
test2 (mpfr_neg, "mpfr_neg", p, (mpfr_rnd_t) rnd);
test2 (mpfr_log, "mpfr_log", p, (mpfr_rnd_t) rnd);
test2 (mpfr_log2, "mpfr_log2", p, (mpfr_rnd_t) rnd);
test2 (mpfr_log10, "mpfr_log10", p, (mpfr_rnd_t) rnd);
test2 (mpfr_log1p, "mpfr_log1p", p, (mpfr_rnd_t) rnd);
test2 (mpfr_exp, "mpfr_exp", p, (mpfr_rnd_t) rnd);
test2 (mpfr_exp2, "mpfr_exp2", p, (mpfr_rnd_t) rnd);
test2 (mpfr_exp10, "mpfr_exp10", p, (mpfr_rnd_t) rnd);
test2 (mpfr_expm1, "mpfr_expm1", p, (mpfr_rnd_t) rnd);
test2 (mpfr_eint, "mpfr_eint", p, (mpfr_rnd_t) rnd);
test2 (mpfr_sinh, "mpfr_sinh", p, (mpfr_rnd_t) rnd);
test2 (mpfr_cosh, "mpfr_cosh", p, (mpfr_rnd_t) rnd);
test2 (mpfr_tanh, "mpfr_tanh", p, (mpfr_rnd_t) rnd);
test2 (mpfr_asinh, "mpfr_asinh", p, (mpfr_rnd_t) rnd);
test2 (mpfr_acosh, "mpfr_acosh", p, (mpfr_rnd_t) rnd);
test2 (mpfr_atanh, "mpfr_atanh", p, (mpfr_rnd_t) rnd);
test2 (mpfr_sech, "mpfr_sech", p, (mpfr_rnd_t) rnd);
test2 (mpfr_csch, "mpfr_csch", p, (mpfr_rnd_t) rnd);
test2 (mpfr_coth, "mpfr_coth", p, (mpfr_rnd_t) rnd);
test2 (mpfr_asin, "mpfr_asin", p, (mpfr_rnd_t) rnd);
test2 (mpfr_acos, "mpfr_acos", p, (mpfr_rnd_t) rnd);
test2 (mpfr_atan, "mpfr_atan", p, (mpfr_rnd_t) rnd);
test2 (mpfr_cos, "mpfr_cos", p, (mpfr_rnd_t) rnd);
test2 (mpfr_sin, "mpfr_sin", p, (mpfr_rnd_t) rnd);
test2 (mpfr_tan, "mpfr_tan", p, (mpfr_rnd_t) rnd);
test2 (mpfr_sec, "mpfr_sec", p, (mpfr_rnd_t) rnd);
test2 (mpfr_csc, "mpfr_csc", p, (mpfr_rnd_t) rnd);
test2 (mpfr_cot, "mpfr_cot", p, (mpfr_rnd_t) rnd);
test2 (mpfr_erf, "mpfr_erf", p, (mpfr_rnd_t) rnd);
test2 (mpfr_erfc, "mpfr_erfc", p, (mpfr_rnd_t) rnd);
test2 (mpfr_j0, "mpfr_j0", p, (mpfr_rnd_t) rnd);
test2 (mpfr_j1, "mpfr_j1", p, (mpfr_rnd_t) rnd);
test2 (mpfr_y0, "mpfr_y0", p, (mpfr_rnd_t) rnd);
test2 (mpfr_y1, "mpfr_y1", p, (mpfr_rnd_t) rnd);
test2 (mpfr_zeta, "mpfr_zeta", p, (mpfr_rnd_t) rnd);
test2 (mpfr_gamma, "mpfr_gamma", p, (mpfr_rnd_t) rnd);
test2 (mpfr_lngamma, "mpfr_lngamma", p, (mpfr_rnd_t) rnd);
test2 (mpfr_rint, "mpfr_rint", p, (mpfr_rnd_t) rnd);
test2 (mpfr_rint_ceil, "mpfr_rint_ceil", p, (mpfr_rnd_t) rnd);
test2 (mpfr_rint_floor, "mpfr_rint_floor", p, (mpfr_rnd_t) rnd);
test2 (mpfr_rint_round, "mpfr_rint_round", p, (mpfr_rnd_t) rnd);
test2 (mpfr_rint_trunc, "mpfr_rint_trunc", p, (mpfr_rnd_t) rnd);
test2 (mpfr_frac, "mpfr_frac", p, (mpfr_rnd_t) rnd);
test3 (mpfr_add, "mpfr_add", p, (mpfr_rnd_t) rnd);
test3 (mpfr_sub, "mpfr_sub", p, (mpfr_rnd_t) rnd);
test3 (mpfr_mul, "mpfr_mul", p, (mpfr_rnd_t) rnd);
test3 (mpfr_div, "mpfr_div", p, (mpfr_rnd_t) rnd);
test3 (mpfr_agm, "mpfr_agm", p, (mpfr_rnd_t) rnd);
test3 (mpfr_min, "mpfr_min", p, (mpfr_rnd_t) rnd);
test3 (mpfr_max, "mpfr_max", p, (mpfr_rnd_t) rnd);
test3 (reldiff_wrapper, "mpfr_reldiff", p, (mpfr_rnd_t) rnd);
test3 (mpfr_dim, "mpfr_dim", p, (mpfr_rnd_t) rnd);
test3 (mpfr_remainder, "mpfr_remainder", p, (mpfr_rnd_t) rnd);
test3 (mpfr_pow, "mpfr_pow", p, (mpfr_rnd_t) rnd);
pow_int ((mpfr_rnd_t) rnd);
test3 (mpfr_atan2, "mpfr_atan2", p, (mpfr_rnd_t) rnd);
test3 (mpfr_hypot, "mpfr_hypot", p, (mpfr_rnd_t) rnd);
test3a (mpfr_sin_cos, "mpfr_sin_cos", p, (mpfr_rnd_t) rnd);
test4 (mpfr_fma, "mpfr_fma", p, (mpfr_rnd_t) rnd);
test4 (mpfr_fms, "mpfr_fms", p, (mpfr_rnd_t) rnd);
#if MPFR_VERSION >= MPFR_VERSION_NUM(2,4,0)
test2 (mpfr_li2, "mpfr_li2", p, (mpfr_rnd_t) rnd);
test2 (mpfr_rec_sqrt, "mpfr_rec_sqrt", p, (mpfr_rnd_t) rnd);
test3 (mpfr_fmod, "mpfr_fmod", p, (mpfr_rnd_t) rnd);
test3a (mpfr_modf, "mpfr_modf", p, (mpfr_rnd_t) rnd);
test3a (mpfr_sinh_cosh, "mpfr_sinh_cosh", p, (mpfr_rnd_t) rnd);
#endif
}
tests_end_mpfr ();
return 0;
}
void TopologyFatTree::buildTopology(int num_way)
{
assert(is_power2(g_cfg.core_num));
assert(is_power2(num_way));
m_num_way = num_way;
m_max_level = log_int(g_cfg.core_num, m_num_way);
m_num_router_per_level = g_cfg.core_num/m_num_way;
fprintf(stderr, "[Fat Tree] m_num_way=%d m_max_level=%d\n", m_num_way, m_max_level);
fprintf(stderr, "[Fat Tree] m_num_router_per_level=%d\n", m_num_router_per_level);
// check relationship between #cores and #routers.
if (g_cfg.router_num != m_num_router_per_level*m_max_level) {
fprintf(stderr, "[Fat Tree] g_cfg.core_num=%d g_cfg.router_num=%d #routers_required=%d\n",
g_cfg.core_num, g_cfg.router_num, m_num_router_per_level*m_max_level);
g_cfg.router_num = m_num_router_per_level*m_max_level;
fprintf(stderr, "[Fat Tree] We changed g_cfg.router_num=%d.\n", g_cfg.router_num);
}
// topology name
m_topology_name = int2str(m_num_way) + "-way Fat Tree";
// create cores
for (int n=0; n<g_cfg.core_num; n++) {
Core* p_Core = new Core(n, g_cfg.core_num_NIs);
g_Core_vec.push_back(p_Core);
}
// create routers
unsigned int router_id = 0;
for (int l=0; l<m_max_level; l++) {
for (int w=0; w<m_num_router_per_level; w++) {
int router_num_pc;
int router_num_ipc, router_num_epc;
if (l == 0) { // 0-level(external) router
router_num_epc = router_num_ipc = (m_num_way * g_cfg.core_num_NIs);
router_num_pc = m_num_way + router_num_epc;
} else { // internal-level router
router_num_epc = router_num_ipc = 0;
router_num_pc = m_num_way * 2;
}
Router* pRouter = new Router(router_id, router_num_pc, g_cfg.router_num_vc,
router_num_ipc, router_num_epc, g_cfg.router_inbuf_depth);
#ifdef _DEBUG_TOPOLOGY_FTREE
printf("[Fat Tree] router=%d level=%d num_pc=%d num_ipc=%d num_epc=%d\n", pRouter->id(), l, router_num_pc, router_num_ipc, router_num_epc);
#endif
g_Router_vec.push_back(pRouter);
router_id++;
}
}
#ifdef _DEBUG_TOPOLOGY_FTREE
printf("[Fat Tree] # of created routers=%d\n", g_Router_vec.size());
#endif
// core and router connection
int num_cores_in_dim = (int)sqrt(g_cfg.core_num);
int num_routers_in_dim = (int)sqrt(m_num_router_per_level);
// printf("num_cores_in_dim = %d, num_routers_in_dim = %d.\n", num_cores_in_dim, num_routers_in_dim);
for(int n=0; n<m_num_router_per_level; n++){
int router_x_coord = n % num_routers_in_dim;
int router_y_coord = n / num_routers_in_dim;
// FIXME: support only 4-way fat-trees
vector< int > core_id_vec;
core_id_vec.resize(m_num_way);
core_id_vec[0] = 2 * router_x_coord + 2 * num_cores_in_dim * router_y_coord;
core_id_vec[1] = core_id_vec[0] + 1;
core_id_vec[2] = core_id_vec[0] + num_cores_in_dim;
core_id_vec[3] = core_id_vec[2] + 1;
// core to router map: core_id -> (router_id, port_pos (relative))
m_core2router_map[core_id_vec[0]] = make_pair(n, 0);
m_core2router_map[core_id_vec[1]] = make_pair(n, 1);
m_core2router_map[core_id_vec[2]] = make_pair(n, 2);
m_core2router_map[core_id_vec[3]] = make_pair(n, 3);
// router to core map: (router_id, port_pos (relative)) -> core_id
m_router2core_map[make_pair(n, 0)] = core_id_vec[0];
m_router2core_map[make_pair(n, 1)] = core_id_vec[1];
m_router2core_map[make_pair(n, 2)] = core_id_vec[2];
m_router2core_map[make_pair(n, 3)] = core_id_vec[3];
#ifdef _DEBUG_TOPOLOGY_FTREE
printf(" router_id=%d first_core=%d second_core=%d third_core=%d fourth_core=%d\n", n, core_id_vec[0], core_id_vec[1], core_id_vec[2], core_id_vec[3]);
#endif
for (int w=0; w<m_num_way; w++) {
Core * p_Core = g_Core_vec[core_id_vec[w]];
Router * p_Router = g_Router_vec[n];
// map PCs between input-NI and router
for (int ipc=0; ipc<g_cfg.core_num_NIs; ipc++) {
int router_in_pc = p_Router->num_internal_pc() + w * g_cfg.core_num_NIs + ipc;
p_Core->getNIInput(ipc)->attachRouter(p_Router, router_in_pc);
p_Router->appendNIInput(p_Core->getNIInput(ipc));
}
// map PCs between output-NI and router
for (int epc=0; epc<g_cfg.core_num_NIs; epc++) {
int router_out_pc = p_Router->num_internal_pc() + w * g_cfg.core_num_NIs + epc;
p_Core->getNIOutput(epc)->attachRouter(p_Router, router_out_pc);
p_Router->appendNIOutput(p_Core->getNIOutput(epc));
}
}
}
// setup link configuration
for (unsigned int i=0; i<g_Router_vec.size(); i++) {
Router* p_router = g_Router_vec[i];
int router_tree_level = getTreeLevel(p_router);
for (int out_pc=0; out_pc<p_router->num_pc(); out_pc++) {
Link& link = p_router->getLink(out_pc);
link.m_valid = true;
if (router_tree_level == 0) { // external routers
if (out_pc < p_router->num_internal_pc()) {
// up link
link.m_link_name = "U" + int2str(out_pc);
link.m_length_mm *= pow(2.0, (double) (router_tree_level+1));
link.m_delay_factor *= 2;
} else {
// link for core
int attached_core_id = p_router->id() * m_num_way + (out_pc - p_router->num_internal_pc())/g_cfg.core_num_NIs;
link.m_link_name = "C" + int2str(attached_core_id) + "-P" + int2str((out_pc - p_router->num_internal_pc())%g_cfg.core_num_NIs);
link.m_length_mm = 0.0;
}
} else { // internal routers
if (out_pc < p_router->num_pc()/2) {
// up link
if (router_tree_level < m_max_level-1) {
link.m_link_name = "U" + int2str(out_pc);
link.m_length_mm *= pow(2.0, (double) (router_tree_level+1));
link.m_delay_factor *= pow_int(2, router_tree_level+1);
} else {
link.m_valid = false;
}
} else {
// down link
link.m_link_name = "D" + int2str(out_pc - p_router->num_pc()/2);
link.m_length_mm *= pow(2.0, (double) (router_tree_level+0));
link.m_delay_factor *= pow_int(2, router_tree_level);
}
}
}
}
// setup routers
for (int r=0; r<g_cfg.router_num; r++) {
Router * p_router = g_Router_vec[r];
int num_pc = p_router->num_pc();
int num_internal_pc = p_router->num_internal_pc();
int level = getTreeLevel(p_router);
if (level == 0) {//level 0, only need to setup UP connection
vector< pair< int, int > > connNextRouter_vec;
connNextRouter_vec.resize(num_pc);
vector< pair< int, int > > connPrevRouter_vec;
connPrevRouter_vec.resize(num_pc);
//UP
for (int out_pc=0; out_pc<num_pc; out_pc++) {
int next_router_id;
int next_in_pc;
if (out_pc >= num_internal_pc) { // ejection pc ?
next_router_id = INVALID_ROUTER_ID;
next_in_pc = DIR_INVALID;
} else { // internal pc
int up_router_id_scale = (int)pow((double)m_num_way,(double)(level+1));
int up_router_id_base = ((p_router->id() % m_num_router_per_level) / up_router_id_scale) * up_router_id_scale + m_num_router_per_level * (level+1);
next_router_id = m_num_router_per_level + p_router->id() + out_pc*(int)pow((double)m_num_way, (double)level);
if (next_router_id >= (up_router_id_base + up_router_id_scale))
next_router_id -= up_router_id_scale;
next_in_pc = g_Router_vec[next_router_id]->num_internal_pc()/2 + out_pc;
}
connNextRouter_vec[out_pc] = make_pair(next_router_id, next_in_pc);
connPrevRouter_vec[out_pc] = make_pair(next_router_id, next_in_pc);
}//pc
g_Router_vec[r]->setNextRouters(connNextRouter_vec);
g_Router_vec[r]->setPrevRouters(connPrevRouter_vec);
} else if (level>0 && level< m_max_level-1) {// need to setup UP and DOWN connection
//for internal router, num_pc = num_internal_pc
//don't need to separate set ejection pc connection
vector< pair< int, int > > connNextRouter_vec;
connNextRouter_vec.resize(num_pc);
vector< pair< int, int > > connPrevRouter_vec;
connPrevRouter_vec.resize(num_pc);
//UP
for (int out_pc=0; out_pc<num_internal_pc/2; out_pc++){
int next_router_id;
int next_in_pc;
int up_router_id_scale = (int)pow((double)m_num_way,(double)(level+1));
int up_router_id_base = ((p_router->id() % m_num_router_per_level) / up_router_id_scale) * up_router_id_scale + m_num_router_per_level * (level+1);
next_router_id = m_num_router_per_level + p_router->id() + out_pc*(int)pow((double)m_num_way, (double)level);
if (next_router_id >= (up_router_id_base + up_router_id_scale))
next_router_id -= up_router_id_scale;
next_in_pc = g_Router_vec[next_router_id]->num_internal_pc()/2 + out_pc;
connNextRouter_vec[out_pc] = make_pair(next_router_id, next_in_pc);
connPrevRouter_vec[out_pc] = make_pair(next_router_id, next_in_pc);
}//pc
//DOWN
for (int out_pc=num_internal_pc/2; out_pc<num_internal_pc; out_pc++){
// out_pc in for in just used for index, not the real out pc which will be set.
int next_router_id = INVALID_ROUTER_ID;
int next_in_pc = INVALID_PC;
int real_out_pc = INVALID_PC;//this is the real out pc which will be set.
int down_router_id_scale = (int)pow((double)m_num_way,(double)level);
int down_router_id_base = ((p_router->id() % m_num_router_per_level) / down_router_id_scale) * down_router_id_scale + m_num_router_per_level * (level-1);
next_router_id = p_router->id() - m_num_router_per_level + (out_pc - num_internal_pc/2) * (int)pow((double)m_num_way, (double)(level-1));
if (next_router_id >= (down_router_id_base + down_router_id_scale))
next_router_id -= down_router_id_scale;
Router * p_next_router = g_Router_vec[next_router_id];
for ( vector< pair< int, int > >::iterator iter= p_next_router->nextRouters().begin(); iter<p_next_router->nextRouters().begin()+num_internal_pc/2; iter++){//find the proper down_router_id and in_pc
if((*iter).first == p_router->id()){//find the correct one
real_out_pc = (*iter).second;
next_in_pc = real_out_pc - num_internal_pc/2;
break;
}
}
connNextRouter_vec[real_out_pc] = make_pair(next_router_id, next_in_pc);
connPrevRouter_vec[real_out_pc] = make_pair(next_router_id, next_in_pc);
}//pc
g_Router_vec[r]->setNextRouters(connNextRouter_vec);
g_Router_vec[r]->setPrevRouters(connPrevRouter_vec);
}// internal level
else {
vector< pair< int, int > > connNextRouter_vec;
connNextRouter_vec.resize(num_internal_pc);
vector< pair< int, int > > connPrevRouter_vec;
connPrevRouter_vec.resize(num_internal_pc);
//DOWN
//UP set as invalid
for (int out_pc=0; out_pc<num_internal_pc; out_pc++) {
int next_router_id = INVALID_ROUTER_ID;
int next_in_pc = INVALID_PC;
if ( out_pc < num_internal_pc/2){//up
next_router_id = INVALID_ROUTER_ID;
next_in_pc = DIR_INVALID;
connNextRouter_vec[out_pc] = make_pair(next_router_id, next_in_pc);
connPrevRouter_vec[out_pc] = make_pair(next_router_id, next_in_pc);
} else{//down
int real_out_pc = INVALID_PC;//this is the real out pc which will be set.
int down_router_id_scale = (int)pow((double)m_num_way,(double)level);
int down_router_id_base = ((p_router->id() % m_num_router_per_level) / down_router_id_scale) * down_router_id_scale + m_num_router_per_level * (level-1);
next_router_id = p_router->id() - m_num_router_per_level + (out_pc - num_internal_pc/2) * (int)pow((double)m_num_way, (double)(level-1));
if (next_router_id >= (down_router_id_base + down_router_id_scale))
next_router_id -= down_router_id_scale;
Router * p_next_router = g_Router_vec[next_router_id];
for ( vector< pair< int, int > >::iterator iter= p_next_router->nextRouters().begin(); iter<p_next_router->nextRouters().begin()+num_internal_pc/2; iter++){//find the proper down_router_id and in_pc
if((*iter).first == p_router->id()){//find the correct one
real_out_pc = (*iter).second;
next_in_pc = real_out_pc - num_internal_pc/2;
break;
}
}
connNextRouter_vec[real_out_pc] = make_pair(next_router_id, next_in_pc);
connPrevRouter_vec[real_out_pc] = make_pair(next_router_id, next_in_pc);
}
}//pc
g_Router_vec[r]->setNextRouters(connNextRouter_vec);
g_Router_vec[r]->setPrevRouters(connPrevRouter_vec);
}// top level
}//router
}
void polynomialBasis::ddf(double u, double v, double w,
double hess[][3][3]) const
{
switch(monomials.size2()) {
case 1:
for(int i = 0; i < coefficients.size1(); i++) {
hess[i][0][0] = hess[i][0][1] = hess[i][0][2] = 0;
hess[i][1][0] = hess[i][1][1] = hess[i][1][2] = 0;
hess[i][2][0] = hess[i][2][1] = hess[i][2][2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 1) // second derivative !=0
hess[i][0][0] += coefficients(i, j) *
pow_int(u, (monomials(j, 0) - 2)) * monomials(j, 0) *
(monomials(j, 0) - 1);
}
}
break;
case 2:
for(int i = 0; i < coefficients.size1(); i++) {
hess[i][0][0] = hess[i][0][1] = hess[i][0][2] = 0;
hess[i][1][0] = hess[i][1][1] = hess[i][1][2] = 0;
hess[i][2][0] = hess[i][2][1] = hess[i][2][2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 1) // second derivative !=0
hess[i][0][0] += coefficients(i, j) *
pow_int(u, (monomials(j, 0) - 2)) * monomials(j, 0) *
(monomials(j, 0) - 1) * pow_int(v, monomials(j, 1));
if((monomials(j, 1) > 0) && (monomials(j, 0) > 0))
hess[i][0][1] += coefficients(i, j) *
pow_int(u, monomials(j, 0) - 1) * monomials(j, 0) *
pow_int(v, monomials(j, 1) - 1) * monomials(j, 1);
if(monomials(j, 1) > 1)
hess[i][1][1] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1) - 2) * monomials(j, 1) *
(monomials(j, 1) - 1);
}
hess[i][1][0] = hess[i][0][1];
}
break;
case 3:
for(int i = 0; i < coefficients.size1(); i++) {
hess[i][0][0] = hess[i][0][1] = hess[i][0][2] = 0;
hess[i][1][0] = hess[i][1][1] = hess[i][1][2] = 0;
hess[i][2][0] = hess[i][2][1] = hess[i][2][2] = 0;
for(int j = 0; j < coefficients.size2(); j++) {
if(monomials(j, 0) > 1)
hess[i][0][0] += coefficients(i, j) *
pow_int(u, monomials(j, 0) - 2) * monomials(j, 0) *
(monomials(j, 0) - 1) * pow_int(v, monomials(j, 1)) *
pow_int(w, monomials(j, 2));
if((monomials(j, 0) > 0) && (monomials(j, 1) > 0))
hess[i][0][1] += coefficients(i, j) *
pow_int(u, monomials(j, 0) - 1) * monomials(j, 0) *
pow_int(v, monomials(j, 1) - 1) * monomials(j, 1) *
pow_int(w, monomials(j, 2));
if((monomials(j, 0) > 0) && (monomials(j, 2) > 0))
hess[i][0][2] += coefficients(i, j) *
pow_int(u, monomials(j, 0) - 1) * monomials(j, 0) *
pow_int(v, monomials(j, 1)) *
pow_int(w, monomials(j, 2) - 1) * monomials(j, 2);
if(monomials(j, 1) > 1)
hess[i][1][1] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1) - 2) * monomials(j, 1) *
(monomials(j, 1) - 1) * pow_int(w, monomials(j, 2));
if((monomials(j, 1) > 0) && (monomials(j, 2) > 0))
hess[i][1][2] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1) - 1) * monomials(j, 1) *
pow_int(w, monomials(j, 2) - 1) * monomials(j, 2);
if(monomials(j, 2) > 1)
hess[i][2][2] += coefficients(i, j) * pow_int(u, monomials(j, 0)) *
pow_int(v, monomials(j, 1)) *
pow_int(w, monomials(j, 2) - 2) * monomials(j, 2) *
(monomials(j, 2) - 1);
}
hess[i][1][0] = hess[i][0][1];
hess[i][2][0] = hess[i][0][2];
hess[i][2][1] = hess[i][1][2];
}
break;
}
}
Real apply(const Uint node_idx, const Uint alpha, const Uint gamma)
{
return ::sqrt(pow_int(m_brown.apply(node_idx, alpha, gamma), 2) + pow_int(m_dns.apply(node_idx, alpha, gamma), 2));
}
