double sq::map_eta(double eta) {
double x = a2 * spow(cos(eta), 1/e1);
double y = a3 * spow(sin(eta), 1/e1);
return (atan2(y, x));
}
vector sq::r(double eta, double omega) const {
vector result(4);
result.el(0) = a1 * spow(cos(eta), e1) * spow(cos(omega), e2);
result.el(1) = a2 * spow(cos(eta), e1) * spow(sin(omega), e2);
result.el(2) = a3 * spow(sin(eta), e1);
result.el(3) = 1.0;
return result;
}
vector sq::normal(double eta, double omega) const {
vector result(4);
result.el(0) = spow(cos(eta), 2.0 - e1) * spow(cos(omega), 2.0 - e2) / a1;
result.el(1) = spow(cos(eta), 2.0 - e1) * spow(sin(omega), 2.0 - e2) / a2;
result.el(2) = spow(sin(eta), 2.0 - e1) / a3;
result.el(3) = 1.0;
result = (1.0 / result.norm()) * (matrix)result;
return result;
}
Matrix CalculateJacobian(Matrix jcb)
{
int i, j, k, ns, sidx[MAXSUBST/2];
double pr;
Reaction *r;
Educt *e;
Product *p;
double f[MAXSUBST/2], tmp;
jcb = AdjustJacob(jcb, nfast);
UnityMatrix(nfast, jcb);
for (i = nfast; i--; )
fast[i]->dcdt = 0.;
for (i = nreact, r = reaction; i--; r++) {
ns = 0;
pr = r->Ke;
for (j = r->neduct, e = r->educt; j--; e++) {
if (e->comp->fastidx >= 0) {
f[ns] = pr * e->prefact * spow(CONZ(e->comp->subs), e->prefact-1);
sidx[ns] = e->comp->fastidx;
}
tmp = spow(CONZ(e->comp->subs), e->prefact);
pr *= tmp;
for (k = ns; k--; )
f[k] *= tmp;
ns += (e->comp->fastidx >= 0);
if (ns > MAXSUBST/2) {
fprintf(stderr, "Fatal error ns = %i\n", ns);
exit (3);
}
}
r->rate = pr;
for (j = r->neduct, e = r->educt; j--; e++) {
if (e->comp->fastidx >= 0) {
e->comp->dcdt -= (double)e->prefact * pr;
for (k = ns; k--; )
jcb[e->comp->fastidx][sidx[k]] += (double)e->prefact * f[k];
}
}
for (j = r->nproduct, p = r->product; j--; p++) {
if (p->comp->fastidx >= 0) {
p->comp->dcdt += p->prefact * pr;
for (k = ns; k--; )
jcb[p->comp->fastidx][sidx[k]] -= p->prefact * f[k];
}
}
}
return (jcb);
}
void CalcRateConstants(double T, double dt, double density, double press, double cozen, double *photorate)
{
double Ti, secans, conv, cloudfact, Rsum, M, k0t, kinft;
Reaction *r;
int i;
BOOL daytime;
Ti = -1./T;
M = press / (T * kBoltz) * 1.e-6;
conv = M * 1.e-9;
if (daytime = (cozen > 0.05))
secans = 1. / cozen;
for (i = nreact, r = reaction; i--; r++) {
switch (r->type) {
case THERMAL :
r->Ke = r->K * exp(r->EoR * Ti) * dt;
break;
case THERMAL2 :
r->Ke = r->K * T * T * exp(r->EoR * Ti) * dt;
break;
case TROE :
k0t = r->k0 * pow(T / 300., r->N);
kinft = r->kinf * pow(T / 300., r->M);
r->Ke = r->K * dt * k0t * M / (1. + k0t * M / kinft) *
pow(0.6, 1. / (1. + spow(log10(k0t * M / kinft), 2)));
break;
case TROEQUIL :
k0t = r->k0 * pow(T / 300., r->N);
kinft = r->kinf * pow(T / 300., r->M);
r->Ke = r->K * dt * exp(r->EoR * Ti) *
k0t * M / (1. + k0t * M / kinft) *
pow(0.6, 1. / (1. + spow(log10(k0t * M / kinft), 2)));
break;
case SPECIAL :
r->Ke = r->K * dt * SpecialConst(r->specidx, T, M);
break;
case PHOTODISS :
r->Ke = (daytime ? r->K * exp(r->EoR * secans) * dt : 0.);
break;
case PHOTODISS3 :
r->Ke = (daytime ? r->K * pow(cozen, r->N) * exp(-r->EoR * secans) * dt : 0.);
break;
case TWOSTREAM :
r->Ke = photorate[r->pos] * dt;
}
r->Ke *= spow(conv, r->netot-1);
}
}
int main(int argc, char const *argv[])
{
unsigned long int int_range = spow(2, sizeof(int) * 8) - 1;
unsigned long int char_range = spow(2, sizeof(char) * 8) - 1;
unsigned long int short_range = spow(2, sizeof(short int) * 8) - 1;
unsigned long long int long_range = spow(2, sizeof(long int) * 8) - 1;
printf("Signed Int [%ld,%ld]\n", (int_range/2) - int_range, int_range/2);
printf("Unsigned Int [%d,%ld]\n", 0, int_range);
printf("Signed Char [%ld,%ld]\n", (char_range/2) - char_range, char_range/2);
printf("Unsigned Char [%d,%ld]\n", 0, char_range);
printf("Signed Short [%ld,%ld]\n", (short_range/2) - short_range, short_range/2);
printf("Unsigned Short [%d,%ld]\n", 0, short_range);
printf("Signed Long [%lld,%lld]\n", (long_range/2) - long_range, long_range/2);
printf("Unsigned Long [%d,%llu]\n", 0, long_range);
return 0;
}
int PlaceEduct(char *name, int fact)
{
Substance *newsubs;
int i;
if (!fact) {
fprintf(stderr,
"CHEM-ERROR: Line %i.0 is not allowed as a prefactor. Set to 1.\n",
lineno);
chemerror = 1;
fact = 1;
}
netot += fact;
if (!strcmp(name, "M")) {
fixedconc *= spow(1.e9, fact);
return (0);
}
if (!strcmp(name, "O2")) {
fixedconc *= spow(780.8e6, fact); /* Nach Weischet p.37 */
return (0);
}
if (!strcmp(name, "N2")) {
fixedconc *= spow(209.5e6, fact);
return (0);
}
if (neduct >= MAXEDUCT) {
fprintf(stderr,
"FATAL CHEM-ERROR: Too many reaction educts.\n"
"This version of meteochem supports a maximum of %i.\n", MAXEDUCT);
return (1);
}
if (!(educt[neduct].comp = newsubs = PlaceSubstance(name, FALSE))) return (1);
for (i = neduct; i-- > oldneduct; )
if (newsubs == educt[i].comp) {
fprintf(stderr,
"CHEM-ERROR: Line %i. Substance %s occurs twice in the educts of this reaction.\n",
lineno, name);
chemerror = 1;
}
educt[neduct].prefact = fact;
neduct++;
return (0);
}
void CalcRates(void)
{
int i, j, k;
Reaction *r, **rptr;
Educt *e;
Product *p;
Substance *s;
double h;
for (i = nreact, r = reaction; i--; r++) {
r->rate = r->Ke;
for (j = r->neduct, e = r->educt; j--; e++)
r->rate *= spow(CONZ(e->comp->subs), e->prefact);
/* printf("rate %2i : %13.5le\n", nreact - i, r->rate); */
}
/* printf("\n"); */
nslow = nfast = 0;
for (i = nsubst, s = subst; i--; s++) {
s->ht = 0.;
for (j = s->ndecay, rptr = s->decay; j--; rptr++) {
h = (*rptr)->Ke;
for (k = (*rptr)->neduct, e = (*rptr)->educt; k--; e++)
h *= spow(CONZ(e->comp->subs), e->prefact - (e->comp == s));
s->ht += h;
}
if (allfast || s->take_as_fast || s->ht > 0.1) {
s->fastidx = nfast;
fast[nfast++] = s;
}
else {
s->fastidx = -1;
slow[nslow++] = s;
}
if (CONZ(s->subs) > 0.5 ||
(s->ht < 1. && (s->ht < 1.e-20 || CONZ(s->subs) / s->ht > 1.e-3)))
s->do_transport = 1;
}
}
int main() {
int res, i, n;
char c;
scanf("%d ", &n);
spow(24);
while(n--) {
i = 24;
res = 0;
while((c=getchar())!='\n' && c!='\r' && c!=EOF) {
i--;
if(c=='1') {
res += bi[i];
}
}
printf("%d\n", res);
}
return 0;
}
void ConvertUnits()
{
reaction[nreact].K *= spow(konzunitfact, reaction[nreact].netot-1) * timeunitfact * fixedconc;
}
double sq::map_omega(double omega) {
double x = a2 * spow(cos(omega), 1/e2);
double y = a1 * spow(sin(omega), 1/e2);
return (atan2(y, x));
}
int main() {
int n; scanf("%d", &n);
printf("%d\n", spow(2,n)-1);
f(n, 1, 3);
return 0;
}