int main(void){
double *u_past;
double *u_present;
double delta_x=0.01;
int n_x = (int)(10.0/delta_x);
double delta_t = 1E-4;
int n_t = (int)(2.0/delta_t);
double c = 1.0;
int i;
/*reserva memoria*/
u_past = malloc(n_x * sizeof(double));
u_present = malloc(n_x * sizeof(double));
/*inicializacion*/
initial_condition(u_past, n_x, delta_x);
for(i=0;i<n_t;i++){
update_u(u_present, u_past, n_x,delta_x, delta_t, c);
copy(u_present, u_past, n_x);
}
/*imprime en pantalla*/
print_u(u_past, n_x);
return 0;
}
int main(){
double x_f = 1.0;
int n_x = 1000;
double delta_x = 0.001;
double delta_t = 5E-4;
int n_t = 350.0;
double c = 1.0;
double r = c * delta_t/delta_x;
double *u_past = malloc(n_x*sizeof(double));
double *u_present = malloc(n_x*sizeof(double));
double *u_future = malloc(n_x*sizeof(double));
initial_condition(u_past, n_x, delta_x);
/*print_u(u_past, n_x, delta_x);*/
u_past[0] = 0.0;
u_past[n_x-1] = 0.0;
u_present[0] = 0.0;
u_present[n_x-1] = 0.0;
first_iteration(u_present, u_past, n_x, r);
copy(u_present, u_past, n_x);
/*print_u(u_present, n_x, delta_x);*/
int i;
for(i=0;i<n_t;i++){
update_u(u_future, u_present, u_past, n_x, r);
copy(u_present, u_past, n_x);
copy(u_future, u_present, n_x);
}
print_u(u_present, n_x, delta_x);
return 0;
}
CFSArray<CFSWString> do_all(CFSWString utt, bool print_label, bool print_utt) {
CFSArray<CFSWString> res;
CFSArray<CPTWord> PTW;
utterance_struct u;
u.s = utt;
u.syl_c = 0;
u.phone_c = 0;
u.phra_c = do_phrases(u);
INTPTR word_count = 0;
if (print_utt) fprintf(stderr, "%s\n", ccstr(utt));
for (INTPTR i = 0; i < u.phr_vector.GetSize(); i++) {
u.phr_vector[i].utt_p = i;
phrase2words(u.phr_vector[i], PTW);
word_count += u.phr_vector[i].word_c;
}
CFSArray<CMorphInfos> MRs = Disambiguator.Disambiguate(Linguistic.AnalyzeSentense(PTW));
CFSArray<CMorphInfo> words;
for (INTPTR i = 0; i < MRs.GetSize(); i++)
//for (INTPTR i1 = 0; i1 < MRs[i].m_MorphInfo.GetSize(); i1++)
words.AddItem(MRs[i].m_MorphInfo[0]); //Ühestamistulemuse ühestamise koht
u.word_c = words.GetSize();
word_struct w;
INTPTR utt_phone_c = 1;
INTPTR syl_utt_p = 1;
INTPTR phone_utt_p = 1;
for (INTPTR i = 0; i < u.phr_vector.GetSize(); i++) {
u.phr_vector[i].utt_p = i + 1;
INTPTR syl_phr_p = 1;
INTPTR phone_phr_p = 1;
INTPTR phrase_pho_c = 1;
for (INTPTR i1 = 0; i1 < u.phr_vector[i].word_c; i1++) {
w.utt_p = utt_phone_c++;
w.phr_p = i1 + 1;
w.mi = words[0];
w.mi.m_szRoot += make_char_string(w.mi.m_szEnding) + w.mi.m_szClitic;
w.mi.m_szRoot = w.mi.m_szRoot.ToLower();
// sidesõnad + ei välteta
if ((CFSWString(w.mi.m_cPOS) == L"J") || (w.mi.m_szRoot == L"<ei")) w.mi.m_szRoot.Replace(L"<", L"", 1);
do_syls(w);
u.phr_vector[i].word_vector.AddItem(w);
INTPTR phone_word_p = 1;
INTPTR word_pho_c = 1;
for (INTPTR i2 = 0; i2 < u.phr_vector[i].word_vector[i1].syl_vector.GetSize(); i2++) {
u.syl_c++;
u.phr_vector[i].syl_c++;
u.phr_vector[i].word_vector[i1].syl_c++;
u.phr_vector[i].word_vector[i1].syl_vector[i2].phr_p = syl_phr_p++;
u.phr_vector[i].word_vector[i1].syl_vector[i2].utt_p = syl_utt_p++;
INTPTR syl_phone_c = 1;
do_phones(u.phr_vector[i].word_vector[i1].syl_vector[i2]);
for (INTPTR i3 = 0; i3 < u.phr_vector[i].word_vector[i1].syl_vector[i2].phone_vector.GetSize(); i3++) {
u.phone_c++;
u.phr_vector[i].phone_c = phrase_pho_c++;
u.phr_vector[i].word_vector[i1].phone_c = word_pho_c++;
u.phr_vector[i].word_vector[i1].syl_vector[i2].phone_c = syl_phone_c++;
phone_struct p = u.phr_vector[i].word_vector[i1].syl_vector[i2].phone_vector[i3];
p.utt_p = phone_utt_p++;
p.phr_p = phone_phr_p++;
p.word_p = phone_word_p++;
u.phr_vector[i].word_vector[i1].syl_vector[i2].phone_vector[i3] = p;
}
}
words.RemoveItem(0, 1);
}
}
if (print_label) print_u(u);
res = do_label(u);
return res;
}
CFSArray<CFSWString> do_all(CFSWString utt, bool print_label, bool print_utt) {
CFSArray<CFSWString> res;
CFSArray<CPTWord> PTW;
utterance_struct u;
u.s = utt.ToLower();
u.syl_c = 0;
u.phone_c = 0;
u.phra_c = do_phrases(u);
INTPTR word_count = 0;
if (print_utt) fprintf(stderr, "%s\n", ccstr(utt));
for (INTPTR i = 0; i < u.phr_vector.GetSize(); i++) {
u.phr_vector[i].utt_p = i;
phrase2words(u.phr_vector[i], PTW);
word_count += u.phr_vector[i].word_c;
}
CFSArray<CMorphInfo> words;
for (INTPTR i = 0; i < PTW.GetSize(); i++) {
CMorphInfo MI;
MI.m_szRoot = PTW[i].m_szWord;
words.AddItem(MI);
}
u.word_c = words.GetSize();
word_struct w;
INTPTR utt_phone_c = 1;
INTPTR syl_utt_p = 1;
INTPTR phone_utt_p = 1;
for (INTPTR i = 0; i < u.phr_vector.GetSize(); i++) {
u.phr_vector[i].utt_p = i + 1;
INTPTR syl_phr_p = 1;
INTPTR phone_phr_p = 1;
INTPTR phrase_pho_c = 1;
for (INTPTR i1 = 0; i1 < u.phr_vector[i].word_c; i1++) {
w.utt_p = utt_phone_c++;
w.phr_p = i1 + 1;
w.mi = words[0];
w.mi.m_szRoot += make_char_string(w.mi.m_szEnding) + w.mi.m_szClitic;
w.mi.m_szRoot = w.mi.m_szRoot.ToLower();
do_syls(w);
u.phr_vector[i].word_vector.AddItem(w);
INTPTR phone_word_p = 1;
INTPTR word_pho_c = 1;
for (INTPTR i2 = 0; i2 < u.phr_vector[i].word_vector[i1].syl_vector.GetSize(); i2++) {
u.syl_c++;
u.phr_vector[i].syl_c++;
u.phr_vector[i].word_vector[i1].syl_c++;
u.phr_vector[i].word_vector[i1].syl_vector[i2].phr_p = syl_phr_p++;
u.phr_vector[i].word_vector[i1].syl_vector[i2].utt_p = syl_utt_p++;
INTPTR syl_phone_c = 1;
do_phones(u.phr_vector[i].word_vector[i1].syl_vector[i2]);
for (INTPTR i3 = 0; i3 < u.phr_vector[i].word_vector[i1].syl_vector[i2].phone_vector.GetSize(); i3++) {
u.phone_c++;
u.phr_vector[i].phone_c = phrase_pho_c++;
u.phr_vector[i].word_vector[i1].phone_c = word_pho_c++;
u.phr_vector[i].word_vector[i1].syl_vector[i2].phone_c = syl_phone_c++;
phone_struct p = u.phr_vector[i].word_vector[i1].syl_vector[i2].phone_vector[i3];
p.utt_p = phone_utt_p++;
p.phr_p = phone_phr_p++;
p.word_p = phone_word_p++;
u.phr_vector[i].word_vector[i1].syl_vector[i2].phone_vector[i3] = p;
}
}
words.RemoveItem(0, 1);
}
}
if (print_label) print_u(u);
res = do_label(u);
return res;
}
static void print_hex(uint32_t x)
{
put_char('0');
put_char('x');
print_u(x, 0x10000000, 0x10, "0123456789ABCDEF");
}
static void print_uint32(uint32_t x)
{
print_u(x, 1000000000, 10, "0123456789");
}
// Print signed int
void print_i(const int x) { if(x < 0) putc('-'); print_u((x < 0) ? -x : x); }
static void cpu_desc_summary (struct cpu_desc *cpudesc)
{
printf ("-= CPU Characteristics =-\n");
print_s("Architecture:", cpu_desc_get_architecture (cpudesc));
int cpu_mode = cpu_desc_get_mode (cpudesc);
if (cpu_mode)
{
char mbuf[32], *p = mbuf;
if (cpu_mode & MODE_32BIT)
{
strcpy (p, "32-bit, ");
p += 8;
}
if (cpu_mode & MODE_64BIT)
{
strcpy (p, "64-bit, ");
p += 8;
}
*(p - 2) = '\0';
print_s("CPU op-mode(s):", mbuf);
}
#if !defined(WORDS_BIGENDIAN)
print_s("Byte Order:", "Little Endian");
#else
print_s("Byte Order:", "Big Endian");
#endif
int cpu, ncpus = cpu_desc_get_ncpus (cpudesc);
print_d("CPU(s):", ncpus);
unsigned int nsockets, ncores, nthreads;
get_cputopology_read (&nsockets, &ncores, &nthreads);
print_u("Thread(s) per core:", nthreads);
print_u("Core(s) per socket:", ncores);
print_u("Socket(s):", nsockets);
print_s("Vendor ID:", cpu_desc_get_vendor (cpudesc));
print_s("CPU Family:", cpu_desc_get_family (cpudesc));
print_s("Model:", cpu_desc_get_model (cpudesc));
print_s("Model name:", cpu_desc_get_model_name (cpudesc));
for (cpu = 0; cpu < ncpus; cpu++)
{
printf ("-CPU%d-\n", cpu);
bool cpu_hot_pluggable = get_processor_is_hot_pluggable (cpu);
int cpu_online = get_processor_is_online (cpu);
print_s ("CPU is Hot Pluggable:", cpu_hot_pluggable ?
(cpu_online ? "yes (online)" : "yes (offline)") : "no");
unsigned long latency = cpufreq_get_transition_latency (cpu);
if (latency)
print_s("Maximum Transition Latency:",
cpufreq_duration_to_string (latency));
unsigned long freq_kernel = cpufreq_get_freq_kernel (cpu);
if (freq_kernel > 0)
print_s("Current CPU Frequency:", cpufreq_freq_to_string (freq_kernel));
struct cpufreq_available_frequencies *cpufreqs, *curr;
cpufreqs = curr = cpufreq_get_available_freqs (cpu);
if (curr)
{
print_key_s("Available CPU Frequencies:");
while (curr)
{
printf ("%s ",
cpufreq_freq_to_string
(cpufreq_get_available_freqs_value (curr)));
curr = cpufreq_get_available_freqs_next (curr);
}
printf ("\n");
cpufreq_available_frequencies_unref(cpufreqs);
}
unsigned long freq_min, freq_max;
if (0 == cpufreq_get_hardware_limits (cpu, &freq_min, &freq_max))
{
char *min_s = cpufreq_freq_to_string (freq_min),
*max_s = cpufreq_freq_to_string (freq_max);
print_range_s("Hardware Limits:", min_s, max_s);
free (min_s);
free (max_s);
}
char *freq_governor = cpufreq_get_governor (cpu);
if (freq_governor)
{
print_s ("CPU Freq Current Governor:", freq_governor);
free (freq_governor);
}
char *freq_governors = cpufreq_get_available_governors (cpu);
if (freq_governors)
{
print_s ("CPU Freq Available Governors:", freq_governors);
free (freq_governors);
}
char *freq_driver = cpufreq_get_driver (cpu);
if (freq_driver)
{
print_s ("CPU Freq Driver:", freq_driver);
free (freq_driver);
}
}
char *cpu_virtflag = cpu_desc_get_virtualization_flag (cpudesc);
if (cpu_virtflag)
print_s("Virtualization:", cpu_virtflag);
}
int main()
{
/*------ declarations --------------------------------------------------*/
int i;
gauss_method gsmethod,gsmethod2;
solution u,u2;
toptions options,options2;
parameters params;
ode_sys system;
solver_stat thestat,thestat2;
clock_t clock0, clock1;
time_t wtime0,wtime1;
params.rpar =(val_type *)malloc(MAXPARAM*sizeof(val_type));
params.ipar =(int *)malloc(MAXPARAM*sizeof(int));
u.uu = (val_type *)malloc(MAXNEQ*sizeof(val_type));
u.ee = (val_type *)malloc(MAXNEQ*sizeof(val_type));
u2.uu = (val_type *)malloc(MAXNEQ*sizeof(val_type));
u2.ee = (val_type *)malloc(MAXNEQ*sizeof(val_type));
options.rtol=malloc(MAXNEQ*sizeof(val_type));
options.atol=malloc(MAXNEQ*sizeof(val_type));
# if PREC ==2 //QUADRUPLEPRECISION
int n;
int width = 46;
char buf[128];
# endif
/* ----------- implementation ---------------------------------------*/
/* ----------- integration parameters---------------------------------*/
gsmethod.ns = 6; // Stages.
options.h = POW(2,-7); // Stepsize.
options.sampling=1; //
system.f = Ode1; // Odefun (GaussUserProblem.c: OdePendulum,OdeNBody)
system.ham= Ham1; // Hamiltonian (GaussUserProblem.c: HamPendulum,HamNBody)
system.problem =1; // Initial values (GaussInitData.c).
options.approximation=1; // Approximation: Y^[0] (GaussCommon.c/Yi_init()).
strncpy(thestat.filename, "AllSolve1.bin",STRMAX); // Output filename.
options.algorithm=1; // 1=Jacobi; 11=Seidel;
options.rdigits=0;
options2.rdigits=3;
/* ----------- execution ------------------------------------------*/
printf("Begin execution \n");
printf("method=%i, problem=%i, algorithm=%i\n",gsmethod.ns,system.problem,options.algorithm);
printf("approximation=%i,sampling=%i\n",options.approximation,options.sampling);
#if PREC ==2 //QUADRUPLEPRECISION
printf("options.h=");
n = quadmath_snprintf(buf, sizeof buf, "%+-#*.30Qe", width, options.h);
if ((size_t) n < sizeof buf) printf("%s\n",buf);
#else //DOUBLEPRECISION
printf("options.h=%lg\n", options.h);
#endif
printf("----------------\n");
InitialData (&options,&u,¶ms,&system);
system.params.rpar=¶ms.rpar[0];
system.params.ipar=¶ms.ipar[0];
for (i=0; i<system.neq; i++)
{
options.rtol[i]=RTOL;
options.atol[i]=ATOL;
}
if (options.rdigits>0) options.mrdigits=pow(2,options.rdigits);
if (options2.rdigits>0) options2.mrdigits=pow(2,options2.rdigits);
GaussCoefficients(&gsmethod,&options);
InitStat(&system,&gsmethod,&thestat);
print_u(system.neq, u.uu);
wtime0= time(NULL);
clock0= clock();
select_gauss(&gsmethod, &gsmethod2, &u, &u2,&system,
&options, &options2, &thestat, &thestat2);
clock1=clock();
wtime1= time(NULL);
printf("End execution \n");
if (thestat.convergence==SUCCESS)
{
printf("Execution Correct\n");
printf("convergence=%i. (=0 correct;=-1 incorrect)\n",thestat.convergence);
print_u (system.neq,u.uu);
#if PREC ==2 //QUADRUPLEPRECISION
printf("Max-DE");
n = quadmath_snprintf(buf, sizeof buf, "%+-#*.30Qe", width, thestat.MaxDE);
if ((size_t) n < sizeof buf) printf("%s\n",buf);
#else // DOUBLEPRECISION
printf("Energy MaxDE=%.20lg\n",thestat.MaxDE);
#endif
printf ("\nCPU time:%lg\n", (double) (clock1 - clock0)/CLOCKS_PER_SEC);
printf ("Elapsed wall clock time: %ld\n", (wtime1 - wtime0));
printf ("Elapsed wall clock time: %lg\n", difftime(wtime1, wtime0));
printf("\n");
printf("stepcount=%i\n",thestat.stepcount);
printf("nout=%i\n",thestat.nout);
printf("fixed-point iterations=%i\n",thestat.totitcount);
printf("max fixed-point iterations=%i\n",thestat.maxitcount);
printf("deltaZero iterations=%i\n",thestat.itzero);
printf("\n");
printf ("function ebaluations\n");
printf("fcn=%i\n",thestat.fcn);
printf ("\n");
}
else
{
printf("Execution InCorrect\n");
printf("convergence=%i. (=0 correct;=-1 incorrect)\n",thestat.convergence);
}
free(params.rpar); free(params.ipar);
free(u.uu); free(u.ee);
free(u2.uu); free(u2.ee);
exit(0);
}
