RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/slsalpsim_8cpp_source.html below:

NCBI C++ ToolKit: src/algo/blast/gumbel_params/sls_alp_sim.cpp Source File

64 throw error

(

"Unexpected error"

,4);

66 bool

ee_error_flag=

false

;

67 error

ee_error(

""

,0);

100 double

time_after_tmp;

116 Int4

maximum_number_of_realizations_for_preliminary_simulation=1000;

118 bool

loop_break_flag;

121 bool

lambda_accuracy_flag=

true

;

126 bool

C_calculation=

false

;

130 bool

check_time_flag=

true

;

134

check_time_flag=

false

;

166

lambda_accuracy_flag=

false

;

173 if

(number_tmp>=maximum_number_of_realizations_for_preliminary_simulation-1)

187

loop_break_flag=!(maximum_number_of_realizations_for_preliminary_simulation>

d_n_alp_obj

-1&&

192 while

(!loop_break_flag);

201 if

(memory_after1<=memory_before1)

204 throw error

(

"Unexpected error\n"

,4);

216 if

(time_after1<=time_before1)

228

realizations_number2=

alp_data::Tmin

(maximum_number_of_realizations_for_preliminary_simulation-(

Int4

)1,realizations_number2);

257 bool

C_calculation=

false

;

271

loop_break_flag=

false

;

273 double

time_before_ALP;

274 double

time_during_ALP;

276 Int4

number_of_realizations_with_ALP_pred;

281 bool

check_time_flag=

true

;

285

check_time_flag=

false

;

292

number_of_realizations_with_ALP,

309 double

tmp_lambda=2.0;

320

number_of_realizations_with_ALP_pred=number_of_realizations_with_ALP;

336 if

(time_during_ALP-time_before1>=

d_alp_data

d_max_time

*0.25||number_of_realizations_with_ALP>=realizations_number2||tmp_lambda<=1.0)

344 if

(time_during_ALP<=time_before_ALP)

351 Int4

max_number_of_realizations=(

Int4

)floor(number_of_realizations_with_ALP*(

d_alp_data

d_max_time

*0.35-(time_before_ALP-time_before1))/(time_during_ALP-time_before_ALP));

352

number_of_realizations_with_ALP=

alp_data::Tmin

(realizations_number2,(

Int4

)floor(0.5*number_of_realizations_with_ALP+0.5*max_number_of_realizations));

353 if

(number_of_realizations_with_ALP>=max_number_of_realizations)

358 if

((

double

)(number_of_realizations_with_ALP-number_of_realizations_with_ALP_pred)/(

double

)number_of_realizations_with_ALP_pred<0.005)

360

number_of_realizations_with_ALP=number_of_realizations_with_ALP_pred;

372 while

(!loop_break_flag);

374

realizations_number2=number_of_realizations_with_ALP;

375 Int4

realizations_number2_lambda=number_of_realizations_with_ALP;

378

loop_break_flag=

false

;

380 double

time_before_kill;

381 double

time_during_kill;

383 Int4

number_of_realizations_with_killing_pred;

388 bool

check_time_flag=

false

;

392

check_time_flag=

false

;

401

number_of_realizations_with_killing,

417

number_of_realizations_with_killing_pred=number_of_realizations_with_killing;

439 if

(time_during_kill-time_before1>=

d_alp_data

d_max_time

||number_of_realizations_with_killing>=realizations_number2||tmp_K<=1.0)

449 if

(time_during_kill<=time_before_kill)

456 Int4

max_number_of_realizations=(

Int4

)floor(number_of_realizations_with_killing*(

d_alp_data

d_max_time

-(time_before_kill-time_before1))/(time_during_kill-time_before_kill));

457

number_of_realizations_with_killing=

d_alp_data

Tmin

(realizations_number2,(

Int4

)floor(0.5*number_of_realizations_with_killing+0.5*max_number_of_realizations));

458 if

(number_of_realizations_with_killing>=max_number_of_realizations)

463 if

((

double

)(number_of_realizations_with_killing-number_of_realizations_with_killing_pred)/(

double

)number_of_realizations_with_killing_pred<0.005)

465

number_of_realizations_with_killing=number_of_realizations_with_killing_pred;

475 while

(!loop_break_flag);

477 #ifdef DEBUG_GUMBEL_PARAMS 482 for

(k=0;k<=number_of_realizations_with_killing;k++)

488

realizations_number2=number_of_realizations_with_killing;

489 Int4

realizations_number2_K=number_of_realizations_with_killing;

498 throw error

(

"The program cannot estimate the parameters; please repeat the calculation"

,2);

530 bool

kill_flag=(realizations_number_killing>realizations_number2_K+1+j);

531 bool

lambda_flag=(realizations_number_lambda>realizations_number2_lambda+1+j);

532 Int4

nalp_for_simulation=nalp;

543 if

(kill_flag||lambda_flag)

548 Int4

step_for_time=1;

550 Int4

number_of_unsuccesful_objects=0;

556

kill_flag=(realizations_number_killing>realizations_number2_K+j);

557

lambda_flag=(realizations_number_lambda>realizations_number2_lambda+j);

565 if

(!(kill_flag||lambda_flag))

587 bool

sucess_flag=

false

;

591 if

(realizations_number2_K+j<=realizations_number2_lambda)

613 bool

check_time_flag=

true

;

617

check_time_flag=

false

;

637

number_of_unsuccesful_objects++;

639 if

(number_of_unsuccesful_objects>5+j*eps_tmp)

641 if

(realizations_number2_K+j>realizations_number2_lambda)

645 throw error

(

"The program cannot calculate the parameters\n"

,3);

655 throw error

(

"Unexpected error in ramdomization\n"

,4);

659 if

(realizations_number2_K+j>realizations_number2_lambda)

661 delete

obj;obj=

NULL

;

671 if

(realizations_number2_K+j>realizations_number2_lambda)

698 if

(j%step_for_time==0)

720 Int4

final_realizations_number_killing=kill_j+realizations_number2_K+1;

721 Int4

final_realizations_number_lambda=

alp_data::Tmax

(realizations_number2_lambda+1,j+realizations_number2_K);

725 #ifdef DEBUG_GUMBEL_PARAMS 729 double

time_after100;

732 #ifdef DEBUG_GUMBEL_PARAMS 733

cout<<

"\nActual calculation time is "

<<time_after100-time_before1<<

" seconds\n"

;

734

cout<<

"Actual memory usage is "

d_alp_data

Tmax

(memory_after2,memory_after3)<<

" MBs\n\n"

;

744 bool

inside_simulation_flag;

746

this->

m_CalcTime

=time_after100-time_before1;

749

time_after100-time_before1,

754

inside_simulation_flag,

755

final_realizations_number_lambda,

756

final_realizations_number_killing);

762

ee_error_flag=

true

;

768

ee_error_flag=

true

;

769

ee_error=

error

(

"Internal error in the program\n"

,4);

794 Int4

final_realizations_number_lambda_,

795 Int4

final_realizations_number_killing_)

806 bool

ee_error_flag=

false

;

807 error

ee_error(

""

,0);

823 throw error

(

"Unexpected error"

,4);

827 Int4

total_number=ind2_-ind1_+1;

829

array_ind=

new alp

*[total_number];

836

perm=

new Int4

[total_number];

842 for

(

=0;

<total_number;

++)

847 for

(

=0;

<total_number;

++)

856

ee_error_flag=

true

;

862

ee_error_flag=

true

;

863

ee_error=

error

(

"Internal error in the program\n"

,4);

867 delete

[]array_ind;array_ind=

NULL

;

868 delete

[]perm;perm=

NULL

;

884 for

(

=0;

<dim_;

++)

889 for

(

=0;

<dim_-1;

++)

893

perm_[ind_swap]=perm_[

];

902 Int4

nalp_for_lambda_simulation,

905 bool

&inside_simulation_flag,

906 Int4

final_realizations_number_lambda_,

907 Int4

final_realizations_number_killing_)

909 bool

ee_error_flag=

false

;

910 error

ee_error(

""

,0);

919 double

test_difference;

920 double

test_difference_error;

936 double

alpha_I_error;

938 double

alpha_J_error;

943 Int4

number_of_trials=0;

944 Int4

number_of_trials_threshold=4;

949

final_realizations_number_lambda_,

950

final_realizations_number_killing_,

952

nalp_for_lambda_simulation,

954

inside_simulation_flag,

958

test_difference_error,

987

final_realizations_number_lambda_,

988

final_realizations_number_killing_);

992 while

(!flag&&number_of_trials<=number_of_trials_threshold);

996 throw error

(

"Error - please run the program once again\n"

,2);

1003

ee_error_flag=

true

;

1009

ee_error_flag=

true

;

1010

ee_error=

error

(

"Internal error in the program\n"

,4);

1028 for

(

=0;

<digits_;

++)

1033 for

(

=0;

<digits_;

++)

1056 Int4

number_of_realizations_)

1058 Int4

max_number_of_subsimulations=20;

1059 Int4

min_number_of_subsimulations=3;

1061 Int4

min_number_of_realizations_for_subsimulation=2;

1063 if

(number_of_realizations_<min_number_of_realizations_for_subsimulation*min_number_of_subsimulations)

1065 throw error

(

"Please repeat the simulation or increase calculation time\n"

,1);

1068 Int4

res_subsimulations=(

Int4

)ceil(sqrt((

double

)number_of_realizations_));

1069

res_subsimulations=

alp_data::Tmin

(res_subsimulations,max_number_of_subsimulations);

1070

res_subsimulations=

alp_data::Tmax

(res_subsimulations,min_number_of_subsimulations);

1072 return

res_subsimulations;

1078 Int4

final_realizations_number_lambda_,

1079 Int4

final_realizations_number_killing_,

1081 Int4

nalp_for_lambda_simulation,

1083 bool

&inside_simulation_flag,

1085 double

&lambda_error,

1086 double

&test_difference,

1087 double

&test_difference_error,

1101 double

&sigma_error,

1103 double

&alpha_I_error,

1105 double

&alpha_J_error,

1111 bool

ee_error_flag=

false

;

1112 error

ee_error(

""

,0);

1115 Int4

*d_mult_K_realizations=

NULL

;

1117 double

*lambda_mult=

NULL

;

1118 double

*lambda_mult_error=

NULL

;

1120 double

*C_mult=

NULL

;

1121 double

*C_mult_error=

NULL

;

1123 double

*a_I_mult=

NULL

;

1124 double

*a_I_mult_error=

NULL

;

1126 double

*a_J_mult=

NULL

;

1127 double

*a_J_mult_error=

NULL

;

1129 double

*sigma_mult=

NULL

;

1130 double

*sigma_mult_error=

NULL

;

1132 double

*alpha_I_mult=

NULL

;

1133 double

*alpha_I_mult_error=

NULL

;

1135 double

*alpha_J_mult=

NULL

;

1136 double

*alpha_J_mult_error=

NULL

;

1138 double

*K_C_mult=

NULL

;

1139 double

*K_C_mult_error=

NULL

;

1141 double

*K_mult=

NULL

;

1142 double

*K_mult_error=

NULL

;

1144 void

**alp_distr=

NULL

;

1145 void

**alp_distr_errors=

NULL

;

1147 void

***alp_mult_distr=

NULL

;

1148 void

***alp_mult_distr_errors=

NULL

;

1159 if

(final_realizations_number_killing_>final_realizations_number_lambda_)

1161 throw error

(

"Unexpected error\n"

,4);

1169 double

mult_number_double_lambda=mult_number_lambda;

1170 double

mult_number_double_K=mult_number_lambda;

1231 double

lambda_mult2=0;

1236 double

sigma_mult2=0;

1237 double

alpha_I_mult2=0;

1238 double

alpha_J_mult2=0;

1241 double

lambda_mult2_error=0;

1242 double

C_mult2_error=0;

1243 double

K_C_mult2_error=0;

1244 double

a_I_mult2_error=0;

1245 double

a_J_mult2_error=0;

1246 double

sigma_mult2_error=0;

1247 double

alpha_I_mult2_error=0;

1248 double

alpha_J_mult2_error=0;

1249 double

K_mult2_error=0;

1255 for

(j=0;j<=nalp_for_lambda_simulation;j++)

1271

alp_mult_distr[j]=

NULL

;

1278

alp_mult_distr_errors[j]=

NULL

;

1281

alp_mult_distr[0]=alp_distr;

1282

alp_mult_distr_errors[0]=alp_distr_errors;

1284 Int4

real_number=(

Int4

)floor((

double

)final_realizations_number_lambda_/(double)

d_mult_number

);

1286

d_mult_realizations[0]=final_realizations_number_lambda_;

1291

d_mult_realizations[k]=real_number;

1298

nr_tmp+=d_mult_realizations[k];

1300 for

(j=0;j<=nalp_for_lambda_simulation;j++)

1303

nr_tmp-d_mult_realizations[k],

1306

alp_mult_distr_errors[k],

1314

nr_tmp+=d_mult_realizations[k];

1317 double

test_difference;

1318 double

test_difference_error;

1324

nalp_for_lambda_simulation,

1326

inside_simulation_flag,

1327

nr_tmp-d_mult_realizations[k],

1330

alp_mult_distr_errors[k],

1332

lambda_mult_error[k],

1334

test_difference_error);

1337 if

(!inside_simulation_flag)

1343

lambda_mult2+=lambda_mult[k];

1344

lambda_mult2_error+=lambda_mult[k]*lambda_mult[k];

1353

nalp_for_lambda_simulation,

1355

inside_simulation_flag,

1357

final_realizations_number_lambda_-1,

1363

test_difference_error);

1365 if

(!inside_simulation_flag)

1367 throw error

(

"Error - please run the program once again\n"

,2);

1371

lambda_mult_error[0]=lambda_error;

1379

nr_tmp+=d_mult_realizations[k];

1382

nalp_for_lambda_simulation,

1383

nr_tmp-d_mult_realizations[k],

1386

alp_mult_distr_errors[k],

1388

lambda_mult_error[k],

1393

C_mult2_error+=C_mult[k]*C_mult[k];

1401

nalp_for_lambda_simulation,

1403

final_realizations_number_lambda_-1,

1413

C_mult_error[0]=C_error;

1421

nr_tmp+=d_mult_realizations[k];

1423

nalp_for_lambda_simulation,

1424

nr_tmp-d_mult_realizations[k],

1427

alp_mult_distr_errors[k],

1429

lambda_mult_error[k],

1435

sigma_mult_error[k],

1437

alpha_I_mult_error[k],

1439

alpha_J_mult_error[k]);

1441

a_I_mult2+=a_I_mult[k];

1442

a_I_mult2_error+=a_I_mult[k]*a_I_mult[k];

1444

a_J_mult2+=a_J_mult[k];

1445

a_J_mult2_error+=a_J_mult[k]*a_J_mult[k];

1447

sigma_mult2+=sigma_mult[k];

1448

sigma_mult2_error+=sigma_mult[k]*sigma_mult[k];

1450

alpha_I_mult2+=alpha_I_mult[k];

1451

alpha_I_mult2_error+=alpha_I_mult[k]*alpha_I_mult[k];

1453

alpha_J_mult2+=alpha_J_mult[k];

1454

alpha_J_mult2_error+=alpha_J_mult[k]*alpha_J_mult[k];

1461

nalp_for_lambda_simulation,

1463

final_realizations_number_lambda_-1,

1481

a_I_mult_error[0]=a_I_error;

1483

a_J_mult_error[0]=a_J_error;

1484

sigma_mult[0]=sigma;

1485

sigma_mult_error[0]=sigma_error;

1486

alpha_I_mult[0]=alpha_I;

1487

alpha_I_mult_error[0]=alpha_I_error;

1488

alpha_J_mult[0]=alpha_J;

1489

alpha_J_mult_error[0]=alpha_J_error;

1492

real_number=(

Int4

)floor((

double

)final_realizations_number_killing_/(double)

d_mult_number

);

1495

d_mult_K_realizations[0]=final_realizations_number_killing_;

1500

d_mult_K_realizations[k]=real_number;

1507

nr_tmp+=d_mult_K_realizations[k];

1509 Int4

recommended_level;

1515

nr_tmp-d_mult_K_realizations[k],

1526

K_mult[k]=C_mult[k]*K_C_mult[k];

1533

K_C_mult2+=K_C_mult[k];

1534

K_C_mult2_error+=K_C_mult[k]*K_C_mult[k];

1537

K_mult2_error+=K_mult[k]*K_mult[k];

1542 Int4

recommended_level;

1549

final_realizations_number_killing_-1,

1570

K_C_mult_error[0]=K_C_error;

1573

K_mult_error[0]=K_error;

1598

mult_number_double_lambda=(double)final_realizations_number_lambda_/(

double

)real_number;

1599

mult_number_double_K=(double)final_realizations_number_killing_/(

double

)real_number;

1602

lambda_mult2_error=

alp_reg::sqrt_for_errors

(lambda_mult2_error-lambda_mult2*lambda_mult2)/sqrt((

double

)mult_number_double_lambda);

1604

K_C_mult2_error=

alp_reg::sqrt_for_errors

(K_C_mult2_error-K_C_mult2*K_C_mult2)/sqrt((

double

)mult_number_double_K);

1605

a_I_mult2_error=

alp_reg::sqrt_for_errors

(a_I_mult2_error-a_I_mult2*a_I_mult2)/sqrt((

double

)mult_number_double_lambda);

1606

a_J_mult2_error=

alp_reg::sqrt_for_errors

(a_J_mult2_error-a_J_mult2*a_J_mult2)/sqrt((

double

)mult_number_double_lambda);

1607

sigma_mult2_error=

alp_reg::sqrt_for_errors

(sigma_mult2_error-sigma_mult2*sigma_mult2)/sqrt((

double

)mult_number_double_lambda);

1608

alpha_I_mult2_error=

alp_reg::sqrt_for_errors

(alpha_I_mult2_error-alpha_I_mult2*alpha_I_mult2)/sqrt((

double

)mult_number_double_lambda);

1609

alpha_J_mult2_error=

alp_reg::sqrt_for_errors

(alpha_J_mult2_error-alpha_J_mult2*alpha_J_mult2)/sqrt((

double

)mult_number_double_lambda);

1617

lambda_mult2_error);

1654

alpha_I_mult2_error);

1660

alpha_J_mult2_error);

1689

this->

m_AISbs

.resize(d_mult_number);

1690

this->

m_AJSbs

.resize(d_mult_number);

1692

this->

m_CSbs

.resize(d_mult_number);

1693

this->

m_KSbs

.resize(d_mult_number);

1702

this->

m_AISbs

[k-1]=a_I_mult[k];

1703

this->

m_AJSbs

[k-1]=a_J_mult[k];

1705

this->

m_CSbs

[k-1]=C_mult[k];

1706

this->

m_KSbs

[k-1]=K_mult[k];

1722

ee_error_flag=

true

;

1728

ee_error_flag=

true

;

1729

ee_error=

error

(

"Internal error in the program\n"

,4);

1736 for

(j=1;j<=nalp_for_lambda_simulation;j++)

1741 delete

[]alp_distr;alp_distr=

NULL

;

1746 if

(alp_distr_errors)

1749 for

(j=1;j<=nalp_for_lambda_simulation;j++)

1754 delete

[]alp_distr_errors;alp_distr_errors=

NULL

;

1763 if

(alp_mult_distr[k])

1765 for

(j=1;j<=nalp_for_lambda_simulation;j++)

1770 delete

[]alp_mult_distr[k];alp_mult_distr[k]=

NULL

;

1774 delete

[]alp_mult_distr;alp_mult_distr=

NULL

;

1778 if

(alp_mult_distr_errors)

1783 if

(alp_mult_distr_errors[k])

1785 for

(j=1;j<=nalp_for_lambda_simulation;j++)

1790 delete

[]alp_mult_distr_errors[k];alp_mult_distr_errors[k]=

NULL

;

1794 delete

[]alp_mult_distr_errors;alp_mult_distr_errors=

NULL

;

1798 delete

[]d_mult_realizations;d_mult_realizations=

NULL

;

1799 delete

[]d_mult_K_realizations;d_mult_K_realizations=

NULL

;

1801 delete

[]lambda_mult;lambda_mult=

NULL

;

1802 delete

[]lambda_mult_error;lambda_mult_error=

NULL

;

1804 delete

[]C_mult;C_mult=

NULL

;

1805 delete

[]C_mult_error;C_mult_error=

NULL

;

1807 delete

[]a_I_mult;a_I_mult=

NULL

;

1808 delete

[]a_I_mult_error;a_I_mult_error=

NULL

;

1809 delete

[]a_J_mult;a_J_mult=

NULL

;

1810 delete

[]a_J_mult_error;a_J_mult_error=

NULL

;

1811 delete

[]sigma_mult;sigma_mult=

NULL

;

1812 delete

[]sigma_mult_error;sigma_mult_error=

NULL

;

1813 delete

[]alpha_I_mult;alpha_I_mult=

NULL

;

1814 delete

[]alpha_I_mult_error;alpha_I_mult_error=

NULL

;

1815 delete

[]alpha_J_mult;alpha_J_mult=

NULL

;

1816 delete

[]alpha_J_mult_error;alpha_J_mult_error=

NULL

;

1818 delete

[]K_C_mult;K_C_mult=

NULL

;

1819 delete

[]K_C_mult_error;K_C_mult_error=

NULL

;

1821 delete

[]K_mult;K_mult=

NULL

;

1822 delete

[]K_mult_error;K_mult_error=

NULL

;

1835 double

C_mult2_error)

1837 if

(

!=0&&C_mult2!=0)

1839

C_error=

fabs

(

*C_mult2_error/C_mult2);

1843

C_error=C_mult2_error;

1884 Int4

current_level=(

Int4

)floor(M_min_*0.5);

1885 Int4

recommended_level;

1886 Int4

number_of_unsucesful_objects=0;

1890 for

(

=ind1_;

<=ind2_;

++)

1903 for

(

=ind1_;

<=ind2_;

++)

1913

number_of_unsucesful_objects++;

1914 if

(number_of_unsucesful_objects>5+(ind2_-ind1_+1)*

1918 throw error

(

"The program cannot estimate the parameters.\nPlease try to increase the allowed amount of memory or change parameters of the scoring system to ensure the logarithmic regime of the alignment score\n"

,1);

1920 delete

alp_obj_tmp;alp_obj_tmp=

NULL

;

1936

number_of_unsucesful_objects++;

1937 if

(number_of_unsucesful_objects>5+(ind2_-ind1_+1)*

1941 throw error

(

,1);

1964

current_level=recommended_level;

1969

level_=current_level;

2003

sucess_flag_=

true

;

2005 while

(obj->

d_nalp

<nalp_)

2010

sucess_flag_=

false

;

2011 delete

obj_;obj_=

NULL

;

2024

sucess_flag_=

false

;

2025 delete

obj_;obj_=

NULL

;

2041 bool

C_calculation_,

2042 bool

check_time_flag_)

2044 bool

ee_error_flag=

false

;

2045 error

ee_error(

""

,0);

2047 Int4

&alp_number=nalp_;

2050 void

**alp_distr=

NULL

;

2051 void

**alp_distr_errors=

NULL

;

2060 if

(d_n_alp_obj<ind1_||d_n_alp_obj-1>ind2_)

2062 throw error

(

"Unexpected error\n"

,4);

2065 Int4

nalp_lambda_equilibration=-1;

2089 bool

M_min_flag=

false

;

2090 bool

nalp_flag=

false

;

2093 bool

criterion_flag=

false

;

2094 Int4

number_of_fails=0;

2095 Int4

number_of_fails_threshold=5;

2099 Int4

number_of_unsuccessful_objects=0;

2101 for

(

=ind1_;

<=ind2_;

++)

2109 if

(alp_obj_tmp->

d_nalp

<alp_number+1)

2116

number_of_unsuccessful_objects++;

2120 if

(number_of_unsuccessful_objects>5+(ind2_-

d_n_alp_obj

+1)*

2125 throw error

(

"The parameters cannot be correctly calculated for the given accuracy, calculation time and memory usage\n"

,1);

2129 bool

success2=

false

;

2137 for

(j=0;j<=alp_number;j++)

2150

number_of_unsuccessful_objects++;

2151 if

(number_of_unsuccessful_objects>5+(ind2_-

d_n_alp_obj

+1)*

2156 throw error

(

"The parameters cannot be correctly calculated for the given accuracy, calculation time and memory usage\n"

,1);

2171 bool

inside_simulation_flag=

false

;

2183

inside_simulation_flag,

2187 if

(nalp_lambda_equilibration==-1&&nalp_flag)

2189

nalp_lambda_equilibration=alp_number;

2194 if

(!inside_simulation_flag)

2201 for

(

=1;

<=alp_number;

++)

2206 delete

[]alp_distr;alp_distr=

NULL

;

2209 if

(alp_distr_errors)

2211 for

(

=1;

<=alp_number;

++)

2216 delete

[]alp_distr_errors;alp_distr_errors=

NULL

;

2225

alp_distr_errors=

NULL

;

2229

criterion_flag=

false

;

2233 for

(

=ind1_;

<=ind2_;

++)

2236 delete

alp_obj_tmp;alp_obj_tmp=

NULL

;

2240 if

(number_of_fails>number_of_fails_threshold)

2242 throw error

(

"The program is not able to calculate the parameters accurately.\nPlease try to increase the allowed calculation time and memory limit\n"

,1);

2245 for

(

=ind1_;

<=ind2_;

++)

2261 while

(!criterion_flag);

2264

nalp_lambda_=

alp_data::Tmax

(nalp_lambda_equilibration,nalp_lambda_);

2272

ee_error_flag=

true

;

2278

ee_error_flag=

true

;

2279

ee_error=

error

(

"Internal error in the program\n"

,4);

2287 for

(

=1;

<=nalp_;

++)

2292 delete

[]alp_distr;alp_distr=

NULL

;

2295 if

(alp_distr_errors)

2298 for

(

=1;

<=nalp_;

++)

2303 delete

[]alp_distr_errors;alp_distr_errors=

NULL

;

2317 Int4

&nalp_for_lambda_simulation_,

2321 void

**&alp_distr_errors,

2325 bool

&inside_simulation_flag_,

2326 bool

C_calculation_)

2330

M_min_flag_=

false

;

2334 throw error

(

"Unexpected error\n"

,4);

2340 double

lambda_error;

2342 double

test_difference;

2343 double

test_difference_error;

2345 Int4

nalp=upto_nalp_;

2349 throw error

(

"Unexpected error\n"

,4);

2364

nalp_for_lambda_simulation_,

2365

inside_simulation_flag_,

2373

test_difference_error);

2375 if

(!inside_simulation_flag_)

2415 if

(test_difference<=test_difference_error)

2436 double

*&exp_array_)

2438 if

(exp_array_[i_]==-1)

2440 throw error

(

"The program is not able to calculate the parameters; rescaling penalties and scoring matrix might help\n"

,3);

2443 return

exp_array_[i_];

2451 void

**alp_distr_errors,

2453 double

lambda_error_,

2459 double

&sigma_error_,

2461 double

&alpha_I_error_,

2463 double

&alpha_J_error_)

2465 bool

ee_error_flag=

false

;

2466 error

ee_error(

""

,0);

2468 double

*exp_array=

NULL

;

2470 double

*delta_E=

NULL

;

2471 double

*delta_E_error=

NULL

;

2473 double

*delta_E_E=

NULL

;

2474 double

*delta_E_E_error=

NULL

;

2477 double

*delta_I=

NULL

;

2478 double

*delta_I_error=

NULL

;

2480 double

*delta_J=

NULL

;

2481 double

*delta_J_error=

NULL

;

2483 double

*delta_I_I=

NULL

;

2484 double

*delta_I_I_error=

NULL

;

2486 double

*delta_I_J=

NULL

;

2487 double

*delta_I_J_error=

NULL

;

2489 double

*delta_J_J=

NULL

;

2490 double

*delta_J_J_error=

NULL

;

2492 double

*cov_J_J=

NULL

;

2493 double

*cov_J_J_error=

NULL

;

2495 double

*cov_I_J=

NULL

;

2496 double

*cov_I_J_error=

NULL

;

2498 double

*cov_I_I=

NULL

;

2499 double

*cov_I_I_error=

NULL

;

2501 double

*cov_E_E=

NULL

;

2502 double

*cov_E_E_error=

NULL

;

2504 const double

dbl_max_log =

log

(DBL_MAX);

2514 throw error

(

"Unexpected error\n"

,4);

2520

exp_array=

new double

[dim+1];

2525 for

(

=0;

<=dim;

++)

2527 double tmp

=(double)

*lambda_;

2528 if

(

tmp

<dbl_max_log)

2530

exp_array[

]=exp(

tmp

);

2541

delta_E=

new double

[nalp_];

2543

delta_E_error=

new double

[nalp_];

2546

delta_E_E=

new double

[nalp_];

2548

delta_E_E_error=

new double

[nalp_];

2551

cov_E_E=

new double

[nalp_];

2553

cov_E_E_error=

new double

[nalp_];

2557

delta_I=

new double

[nalp_];

2559

delta_I_error=

new double

[nalp_];

2562

delta_J=

new double

[nalp_];

2564

delta_J_error=

new double

[nalp_];

2567

delta_I_I=

new double

[nalp_];

2569

delta_I_I_error=

new double

[nalp_];

2572

delta_I_J=

new double

[nalp_];

2574

delta_I_J_error=

new double

[nalp_];

2577

delta_J_J=

new double

[nalp_];

2579

delta_J_J_error=

new double

[nalp_];

2582

cov_J_J=

new double

[nalp_];

2584

cov_J_J_error=

new double

[nalp_];

2587

cov_I_J=

new double

[nalp_];

2589

cov_I_J_error=

new double

[nalp_];

2592

cov_I_I=

new double

[nalp_];

2594

cov_I_I_error=

new double

[nalp_];

2598 for

(j=0;j<nalp_;j++)

2601

delta_E_error[j]=0.0;

2604

delta_E_E_error[j]=0.0;

2607

delta_I_error[j]=0.0;

2609

delta_J_error[j]=0.0;

2613

delta_I_I_error[j]=0.0;

2615

delta_I_J_error[j]=0.0;

2617

delta_J_J_error[j]=0.0;

2621 for

(

=ind1_;

<=ind2_;

++)

2626 for

(j=1;j<=nalp_;j++)

2640 double

delta_I_tmp=(I_j-I_j_1)*

lambda_exp

(E_j,exp_array)*weight_j;

2641 double

delta_J_tmp=(J_j-J_j_1)*

lambda_exp

(E_j,exp_array)*weight_j;

2642 double

delta_E_tmp=(E_j-E_j_1)*

lambda_exp

(E_j,exp_array)*weight_j;

2643 double

delta_E_E_tmp=(E_j-E_j_1)*(E_j-E_j_1)*

lambda_exp

(E_j,exp_array)*weight_j;

2646 double

delta_I_I_tmp=delta_I_tmp*(I_j-I_j_1);

2647 double

delta_J_J_tmp=delta_J_tmp*(J_j-J_j_1);

2648 double

delta_I_J_tmp=delta_I_tmp*(J_j-J_j_1);

2653

delta_E[j_1]+=delta_E_tmp;

2654

delta_E_error[j_1]+=delta_E_tmp*delta_E_tmp;

2656

delta_E_E[j_1]+=delta_E_E_tmp;

2657

delta_E_E_error[j_1]+=delta_E_E_tmp*delta_E_E_tmp;

2659

delta_I[j_1]+=delta_I_tmp;

2660

delta_I_error[j_1]+=delta_I_tmp*delta_I_tmp;

2661

delta_J[j_1]+=delta_J_tmp;

2662

delta_J_error[j_1]+=delta_J_tmp*delta_J_tmp;

2664

delta_I_I[j_1]+=delta_I_I_tmp;

2665

delta_I_I_error[j_1]+=delta_I_I_tmp*delta_I_I_tmp;

2667

delta_I_J[j_1]+=delta_I_J_tmp;

2668

delta_I_J_error[j_1]+=delta_I_J_tmp*delta_I_J_tmp;

2670

delta_J_J[j_1]+=delta_J_J_tmp;

2671

delta_J_J_error[j_1]+=delta_J_J_tmp*delta_J_J_tmp;

2677 double

ind_diff=(double)(ind2_-ind1_+1);

2678 for

(j=0;j<nalp_;j++)

2680

delta_E[j]/=ind_diff;

2681

delta_E_error[j]/=ind_diff;

2682

delta_E_error[j]-=delta_E[j]*delta_E[j];

2683

delta_E_error[j]/=ind_diff;

2686

delta_E_E[j]/=ind_diff;

2687

delta_E_E_error[j]/=ind_diff;

2688

delta_E_E_error[j]-=delta_E_E[j]*delta_E_E[j];

2689

delta_E_E_error[j]/=ind_diff;

2692

delta_I[j]/=ind_diff;

2693

delta_I_error[j]/=ind_diff;

2694

delta_I_error[j]-=delta_I[j]*delta_I[j];

2695

delta_I_error[j]/=ind_diff;

2698

delta_J[j]/=ind_diff;

2699

delta_J_error[j]/=ind_diff;

2700

delta_J_error[j]-=delta_J[j]*delta_J[j];

2701

delta_J_error[j]/=ind_diff;

2704

delta_I_J[j]/=ind_diff;

2705

delta_I_J_error[j]/=ind_diff;

2706

delta_I_J_error[j]-=delta_I_J[j]*delta_I_J[j];

2707

delta_I_J_error[j]/=ind_diff;

2710

delta_I_I[j]/=ind_diff;

2711

delta_I_I_error[j]/=ind_diff;

2712

delta_I_I_error[j]-=delta_I_I[j]*delta_I_I[j];

2713

delta_I_I_error[j]/=ind_diff;

2716

delta_J_J[j]/=ind_diff;

2717

delta_J_J_error[j]/=ind_diff;

2718

delta_J_J_error[j]-=delta_J_J[j]*delta_J_J[j];

2719

delta_J_J_error[j]/=ind_diff;

2722

cov_I_J[j]=delta_I_J[j]-delta_I[j]*delta_J[j];

2723

cov_I_I[j]=delta_I_I[j]-delta_I[j]*delta_I[j];

2724

cov_J_J[j]=delta_J_J[j]-delta_J[j]*delta_J[j];

2726

cov_E_E[j]=delta_E_E[j]-delta_E[j]*delta_E[j];

2729

cov_I_J_error[j]=sqrt(delta_I_J_error[j]+cov_I_J_error[j]*cov_I_J_error[j]);

2732

cov_I_I_error[j]=sqrt(delta_I_I_error[j]+cov_I_I_error[j]*cov_I_I_error[j]);

2735

cov_J_J_error[j]=sqrt(delta_J_J_error[j]+cov_J_J_error[j]*cov_J_J_error[j]);

2738

cov_E_E_error[j]=sqrt(delta_E_E_error[j]+cov_E_E_error[j]*cov_E_E_error[j]);

2746 double

beta1_error=0;

2748 Int4

number_of_elements=nalp_;

2750 bool

cut_left_tail=

true

;

2751 bool

cut_right_tail=

false

;

2759 double

delta_I_aver;

2760 double

delta_I_aver_error;

2764 bool

res_was_calculated;

2780

res_was_calculated);

2782 if

(!res_was_calculated)

2784 throw error

(

"The program cannot estimate the parameters; please repeat the calculation2\n"

,2);

2789 double

delta_J_aver;

2790 double

delta_J_aver_error;

2808

res_was_calculated);

2810 if

(!res_was_calculated)

2812 throw error

(

"The program cannot estimate the parameters; please repeat the calculation3\n"

,2);

2816 double

delta_E_aver;

2817 double

delta_E_aver_error;

2833

res_was_calculated);

2835 if

(!res_was_calculated)

2837 throw error

(

"The program cannot estimate the parameters; please repeat the calculation4\n"

,2);

2840 double

cov_I_I_aver;

2841 double

cov_I_I_aver_error;

2843 double

cov_I_J_aver;

2844 double

cov_I_J_aver_error;

2846 double

cov_J_J_aver;

2847 double

cov_J_J_aver_error;

2849 double

cov_E_E_aver;

2850 double

cov_E_E_aver_error;

2867

res_was_calculated);

2869 if

(!res_was_calculated)

2871 throw error

(

"The program cannot estimate the parameters; please repeat the calculation5\n"

,2);

2888

res_was_calculated);

2890 if

(!res_was_calculated)

2892 throw error

(

"The program cannot estimate the parameters; please repeat the calculation6\n"

,2);

2909

res_was_calculated);

2911 if

(!res_was_calculated)

2913 throw error

(

"The program cannot estimate the parameters; please repeat the calculation7\n"

,2);

2930

res_was_calculated);

2932 if

(!res_was_calculated)

2934 throw error

(

"The program cannot estimate the parameters; please repeat the calculation7_E\n"

,2);

2939 if

(delta_E_aver<=0)

2941 throw error

(

"FSC parameters estimations failed\n"

,2);

2946

a_I_=delta_I_aver/delta_E_aver;

2948

a_J_=delta_J_aver/delta_E_aver;

3000

ee_error_flag=

true

;

3006

ee_error_flag=

true

;

3007

ee_error=

error

(

"Internal error in the program\n"

,4);

3011 delete

[]exp_array;exp_array=

NULL

;

3013 delete

[]delta_E;delta_E=

NULL

;

3014 delete

[]delta_E_error;delta_E_error=

NULL

;

3015 delete

[]delta_E_E;delta_E_E=

NULL

;

3016 delete

[]delta_E_E_error;delta_E_E_error=

NULL

;

3017 delete

[]delta_I;delta_I=

NULL

;

3018 delete

[]delta_I_error;delta_I_error=

NULL

;

3019 delete

[]delta_J;delta_J=

NULL

;

3020 delete

[]delta_J_error;delta_J_error=

NULL

;

3022 delete

[]delta_I_J;delta_I_J=

NULL

;

3023 delete

[]delta_I_J_error;delta_I_J_error=

NULL

;

3024 delete

[]delta_J_J;delta_J_J=

NULL

;

3025 delete

[]delta_J_J_error;delta_J_J_error=

NULL

;

3026 delete

[]delta_I_I;delta_I_I=

NULL

;

3027 delete

[]delta_I_I_error;delta_I_I_error=

NULL

;

3029 delete

[]cov_I_J;cov_I_J=

NULL

;

3030 delete

[]cov_I_J_error;cov_I_J_error=

NULL

;

3031 delete

[]cov_J_J;cov_J_J=

NULL

;

3032 delete

[]cov_J_J_error;cov_J_J_error=

NULL

;

3033 delete

[]cov_I_I;cov_I_I=

NULL

;

3034 delete

[]cov_I_I_error;cov_I_I_error=

NULL

;

3035 delete

[]cov_E_E;cov_E_E=

NULL

;

3036 delete

[]cov_E_E_error;cov_E_E_error=

NULL

;

3046 double

delta_I_aver_,

3047 double

delta_I_aver_error_,

3048 double

delta_J_aver_,

3049 double

delta_J_aver_error_,

3050 double

delta_E_aver_,

3051 double

delta_E_aver_error_,

3052 double

cov_E_E_aver_,

3053 double

cov_E_E_aver_error_,

3054 double

cov_I_J_aver_,

3055 double

cov_I_J_aver_error_,

3057 double

&alpha_error_)

3059 double

nom1_1=delta_I_aver_*delta_J_aver_;

3060 double

nom2_2=delta_E_aver_*delta_E_aver_;

3062 double

den=nom2_2*delta_E_aver_;

3064 double

nom1=nom1_1*cov_E_E_aver_;

3065 double

nom2=nom2_2*cov_I_J_aver_;

3067

alpha_=(nom1+nom2)/den;

3089 Int4

starting_point,

3094 void

**alp_distr_errors,

3096 double

lambda_error_,

3100 bool

ee_error_flag=

false

;

3101 error

ee_error(

""

,0);

3104 double

*P_errors=

NULL

;

3105 double

*values_P_ratio=

NULL

;

3106 double

*errors_P_ratio=

NULL

;

3109 double

*E_errors=

NULL

;

3111 double

*E_T_beta=

NULL

;

3112 double

*E_T_beta_errors=

NULL

;

3120 Int4

total_number_of_ALP=nalp_;

3122 if

(total_number_of_ALP<1)

3124 throw error

(

"Unexpected error\n"

,4);

3132 P

new double

[total_number_of_ALP+1];

3134

P_errors=

new double

[total_number_of_ALP+1];

3141 for

(j=1;j<=total_number_of_ALP;j++)

3149 for

(

=0;

tmp

->d_dim;

++)

3151 P

[j]+=

tmp

->d_elem[

];

3152

P_errors[j]+=tmp_errors->

d_elem

[

];

3160

values_P_ratio=

new double

[total_number_of_ALP];

3162

errors_P_ratio=

new double

[total_number_of_ALP];

3167 for

(j=0;j<total_number_of_ALP;j++)

3169

values_P_ratio[j]=

[j+1]/

[j];

3176 double

beta1_error=0;

3178 Int4

number_of_elements=total_number_of_ALP;

3180 bool

cut_left_tail=

true

;

3181 bool

cut_right_tail=

false

;

3190 double

P_beta_inf_error=0;

3192 bool

res_was_calculated;

3196

number_of_elements-starting_point,

3197

values_P_ratio+starting_point,

3198

errors_P_ratio+starting_point,

3208

res_was_calculated);

3213 if

(!res_was_calculated)

3215 throw error

(

"The program cannot estimate the parameters; please repeat the calculation\n"

,2);

3218

P_beta_inf=1-P_beta_inf;

3222 E

new double

[total_number_of_ALP+1];

3224

E_errors=

new double

[total_number_of_ALP+1];

3227

E_T_beta=

new double

[total_number_of_ALP+1];

3229

E_T_beta_errors=

new double

[total_number_of_ALP+1];

3237

E_T_beta_errors[0]=0;

3242 for

(j=1;j<=total_number_of_ALP;j++)

3251

E_T_beta_errors[j]=0;

3254 for

(

=0;

tmp

->d_dim;

++)

3256 double

tmp_double=exp(lambda_*(

double

)

);

3257 E

[j]+=tmp_double*

tmp

->d_elem[

];

3258

E_errors[j]+=tmp_double*tmp_double*tmp_errors->

d_elem

[

];

3260

tmp_double=(double)

*exp(lambda_*(

double

)

);

3261

E_T_beta[j]+=tmp_double*

tmp

->d_elem[

];

3262

E_T_beta_errors[j]+=tmp_double*tmp_double*tmp_errors->

d_elem

[

];

3272 double

E_aver_error;

3274 double

E_T_beta_diff_aver;

3275 double

E_T_beta_diff_aver_error;

3278 if

(total_number_of_ALP==1)

3281

E_aver_error=E_errors[1];

3283

E_T_beta_diff_aver=E_T_beta[1]-E_T_beta[0];

3284

E_T_beta_diff_aver_error=E_T_beta_errors[1];

3289 Int4

number_of_elements=total_number_of_ALP;

3291 bool

cut_left_tail=

true

;

3292 bool

cut_right_tail=

false

;

3298 double

beta1_error=0;

3300 bool

res_was_calculated;

3304

number_of_elements-starting_point,

3305 E

+1+starting_point,

3306

E_errors+1+starting_point,

3316

res_was_calculated);

3319 if

(!res_was_calculated)

3321 throw error

(

"The program cannot estimate the parameters; please repeat the calculation\n"

,2);

3325

number_of_elements=total_number_of_ALP;

3330

number_of_elements-starting_point,

3331

E_T_beta+1+starting_point,

3332

E_T_beta_errors+1+starting_point,

3342

res_was_calculated);

3346 if

(!res_was_calculated)

3348 throw error

(

"The program cannot estimate the parameters; please repeat the calculation\n"

,2);

3352

E_T_beta_diff_aver=beta1;

3353

E_T_beta_diff_aver_error=beta1_error;

3359 double

exp_lambda_error=exp(-lambda_)*lambda_error_;

3360 double

exp_lambda=(1-exp(-lambda_));

3364 double

den=(1-exp(-lambda_))*E_T_beta_diff_aver;

3367 double

E_aver_sqr=E_aver*E_aver;

3370 double

nom=P_beta_inf*E_aver_sqr;

3381

ee_error_flag=

true

;

3387

ee_error_flag=

true

;

3388

ee_error=

error

(

"Internal error in the program\n"

,4);

3393 delete

[]values_P_ratio;values_P_ratio=

NULL

;

3394 delete

[]errors_P_ratio;errors_P_ratio=

NULL

;

3398 delete

[]P_errors;P_errors=

NULL

;

3401 delete

[]E_T_beta;E_T_beta=

NULL

;

3402 delete

[]E_errors;E_errors=

NULL

;

3403 delete

[]E_T_beta_errors;E_T_beta_errors=

NULL

;

3416 void

**&alp_distr_errors,

3423 throw error

(

"Unexpected error\n"

,4);

3427

alp_distr_errors=

NULL

;

3432 void

**alp_distr_tmp=

NULL

;

3433 void

**alp_distr_errors_tmp=

NULL

;

3435 Int4

allocation_dim=nalp;

3436 Int4

allocation_dim_tmp=nalp+1;

3438 bool

ee_error_flag=

false

;

3439 error

ee_error(

""

,0);

3448

alp_distr_tmp=

new void

*[nalp+1];

3451

alp_distr_errors_tmp=

new void

*[nalp+1];

3454 for

(

=0;

<=nalp;

++)

3456

alp_distr_tmp[

NULL

;

3457

alp_distr_errors_tmp[

NULL

;

3461 for

(

=1;

<=nalp-1;

++)

3463

alp_distr_tmp[

]=alp_distr[

];

3464

alp_distr_errors_tmp[

]=alp_distr_errors[

];

3467 delete

[]alp_distr;alp_distr=

NULL

;

3468 delete

[]alp_distr_errors;alp_distr_errors=

NULL

;

3470

alp_distr=alp_distr_tmp;alp_distr_tmp=

NULL

;

3471

alp_distr_errors=alp_distr_errors_tmp;alp_distr_errors_tmp=

NULL

;

3473

allocation_dim=nalp+1;

3485 for

(

=ind1_;

<=ind2_;

++)

3497 double

ind_diff=(double)(ind2_-ind1_+1);

3502 for

(j=0;j<=

tmp

->d_dim;j++)

3504 tmp

->d_elem[j]/=ind_diff;

3505

tmp_errors->

d_elem

[j]/=ind_diff;

3506

tmp_errors->

d_elem

[j]-=

tmp

->d_elem[j]*

tmp

->d_elem[j];

3507

tmp_errors->

d_elem

[j]/=ind_diff;

3512

ee_error_flag=

true

;

3518

ee_error_flag=

true

;

3519

ee_error=

error

(

"Internal error in the program\n"

,4);

3529 for

(

=0;

<=allocation_dim_tmp;

++)

3533 delete

[]alp_distr_tmp;alp_distr_tmp=

NULL

;

3536 if

(alp_distr_errors_tmp)

3538 for

(

=0;

<=allocation_dim_tmp;

++)

3542 delete

[]alp_distr_errors_tmp;alp_distr_errors_tmp=

NULL

;

3547 for

(

=0;

<=allocation_dim;

++)

3551 delete

[]alp_distr;alp_distr=

NULL

;

3554 if

(alp_distr_errors)

3556 for

(

=0;

<=allocation_dim;

++)

3560 delete

[]alp_distr_errors;alp_distr_errors=

NULL

;

3579 throw error

(

"Unexpected error\n"

,4);

3581 bool

ee_error_flag=

false

;

3582 error

ee_error(

""

,0);

3593 double

sum_of_weights=0;

3597 for

(

=ind1_;

<=ind2_;

++)

3602

sum_of_weights+=weight_tmp;

3603

M_aver+=alp_tmp*weight_tmp;

3617 for

(

=0;

<=diff->

d_dim

;

++)

3619

den+=exp(-lambda_*(

double

)

)*diff->

d_elem

[

];

3623 if

(den<=0||sum_of_weights<=0)

3625 throw error

(

"The program is not able to estimate the parameters\n"

,2);

3629

M_aver/=sum_of_weights;

3632 double

delta_val=den*eps_K_*(1-exp(-lambda_));

3635 for

(

=diff->

d_dim

;

>=0;

--)

3637 if

(exp(-lambda_*(

double

)

)*diff->

d_elem

[

]>delta_val)

3650 delete

diff;diff=

NULL

;

3651 if

(M_aver<diff_opt)

3660

ee_error_flag=

true

;

3666

ee_error_flag=

true

;

3667

ee_error=

error

(

"Internal error in the program\n"

,4);

3672 delete

diff;diff=

NULL

;

3687 Int4

current_level_,

3688 Int4

&recommended_level_,

3695 throw error

(

"Unexpected error\n"

,4);

3701 bool

ee_error_flag=

false

;

3702 error

ee_error(

""

,0);

3716 double

sum_of_weights=0;

3717 double

sum_of_weights_error=0;

3722 for

(

=ind1_;

<=ind2_;

++)

3725 Int4

&alp_tmp=alp_obj_tmp->

d_M

;

3727

sum_of_weights+=weight_tmp;

3728

sum_of_weights_error+=weight_tmp*weight_tmp;

3729

M_aver+=alp_tmp*weight_tmp;

3737 double tmp

=cells_counts->

d_elem

[k-cells_counts->

d_ind0

]*weight_tmp;

3745 double

tmp2=(double)(ind2_-ind1_+1);

3747

sum_of_weights/=tmp2;

3748

sum_of_weights_error/=tmp2;

3749

sum_of_weights_error-=sum_of_weights*sum_of_weights;

3750

sum_of_weights_error/=tmp2;

3755 for

(

=0;

<=diff->

d_dim

;

++)

3758

diff_error->

d_elem

[

]/=tmp2;

3760

diff_error->

d_elem

[

]/=tmp2;

3767 for

(

=0;

<=diff->

d_dim

;

++)

3769 double tmp

=exp(-lambda_*(

double

)

);

3780 if

(den<=0||sum_of_weights<=0)

3782 throw error

(

"The program is not able to estimate the parameters\n"

,2);

3785

K_C_=sum_of_weights/den;

3790

M_aver/=sum_of_weights;

3793 double

delta_val=den*eps_K_*(1-exp(-lambda_));

3796 for

(

=diff->

d_dim

;

>=0;

--)

3798 if

(exp(-lambda_*(

double

)

)*diff->

d_elem

[

]>delta_val)

3805 delete

diff;diff=

NULL

;

3806 delete

diff_error;diff_error=

NULL

;

3808 if

(M_aver-diff_opt<current_level_)

3810

recommended_level_=(

Int4

)floor(M_aver-diff_opt*1.1);

3811

diff_opt_=(

Int4

)ceil(M_aver-recommended_level_);

3814

recommended_level_=current_level_;

3815

diff_opt_=(

Int4

)ceil(M_aver-recommended_level_);

3820

ee_error_flag=

true

;

3826

ee_error_flag=

true

;

3827

ee_error=

error

(

"Internal error in the program\n"

,4);

3834 delete

diff;diff=

NULL

;

3835 delete

diff_error;diff_error=

NULL

;

3846 bool

check_the_criteria_,

3849 bool

&inside_simulation_flag_,

3853 void

**alp_distr_errors,

3855 double

&lambda_error_,

3856 double

&test_difference_,

3857 double

&test_difference_error_)

3863 throw error

(

"Unexpected error\n"

,4);

3871

tmp_struct.

d_nalp

=nalp;

3876 void

* func_pointer=&tmp_struct;

3879 Int4

n_partition=30;

3881

std::vector<double> res;

3897

inside_simulation_flag_=

true

;

3900

inside_simulation_flag_=

false

;

3910 double

f1=func(lambda_,func_pointer);

3914 double

slope_error=tmp_struct.

d_f_error

;

3920 double

delta_lambda=lambda_/100.0;

3921 double

f2=func(lambda_+delta_lambda,func_pointer);

3925 if

(delta_lambda==0||f1==f2)

3931 double

derivative=(f2-f1)/delta_lambda;

3932

lambda_error_=

fabs

(slope_error/derivative);

3935 if

(!check_the_criteria_)

3958

test_difference_=

fabs

((sum1-sum2)/max_sum);

3959

test_difference_error_=0.5*(sum1_error+sum2_error)/max_sum;

3963

test_difference_=-1;

3964

test_difference_error_=0;

3976 const

std::vector<double> &res_tmp_,

3979 if

(res_tmp_.size()==0)

3981 throw error

(

"Error in alp_sim::get_root - the equation does not have roots\n"

,2);

3987 double

d1=

fabs

(point_-res_tmp_[0]);

3988 for

(

=1;

Int4

)res_tmp_.size();

++)

3990 double

d2=

fabs

(point_-res_tmp_[

]);

4009 double

*expect_errors=

NULL

;

4011 bool

ee_error_flag=

false

;

4012 error

ee_error(

""

,0);

4024 expect

new double

[nalp];

4026

expect_errors=

new double

[nalp];

4031 throw error

(

"Unexpected error\n"

,4);

4037 for

(k=1;k<=nalp;k++)

4046 for

(j=0;j<=

tmp

->d_dim;j++)

4048 if

(

tmp

->d_elem[j] <= 0)

4052 double

exp_tmp=exp(lambda_*j);

4053 val

+=exp_tmp*

tmp

->d_elem[j];

4054

val_error+=exp_tmp*exp_tmp*tmp_errors->

d_elem

[j];

4058

expect_errors[k-1]=val_error;

4070 for

(k=0;k<nalp;k++)

4072 if

(expect_errors[k]!=0)

4074 tmp

+=1.0/(expect_errors[k]*expect_errors[k]);

4081 for

(k=nalp-1;k>=0;k--)

4083 if

(expect_errors[k]!=0)

4085 tmp1

+=1.0/(expect_errors[k]*expect_errors[k]);

4100

tmp_struct->

d_f_error

=expect_errors[0];

4102 delete

[]expect_errors;expect_errors=

NULL

;

4108 Int4

number_of_elements=nalp;

4109 bool

cut_left_tail=

true

;

4110 bool

cut_right_tail=

false

;

4119 bool

res_was_calculated;

4135

res_was_calculated);

4137 if

(!res_was_calculated)

4139 throw error

(

"The program cannot estimate the parameters; please repeat the calculation\n"

,2);

4144 delete

[]expect_errors;expect_errors=

NULL

;

4152

ee_error_flag=

true

;

4158

ee_error_flag=

true

;

4159

ee_error=

error

(

"Internal error in the program\n"

,4);

4167 delete

[]expect_errors;expect_errors=

NULL

;

importance_sampling * d_is

struct_for_randomization * d_rand_all

static double round(const double &x_)

static T Tmax(T i_, T j_)

static void get_current_time(double &seconds_)

static T Tmin(T i_, T j_)

Int4 d_minimum_realizations_number

static Int4 random_long(double value_, Int4 dim_)

static void assert_mem(void *pointer_)

double d_memory_size_in_MB

Int4 d_realizations_number2

static double sqrt_for_errors(double x_)

static double error_of_the_product(double v1_, double v1_error_, double v2_, double v2_error_)

static double error_of_the_sum(double v1_, double v1_error_, double v2_, double v2_error_)

static void robust_regression_sum_with_cut_LSM(Int4 min_length_, Int4 number_of_elements_, double *values_, double *errors_, bool cut_left_tail_, bool cut_right_tail_, double y_, double &beta0_, double &beta1_, double &beta0_error_, double &beta1_error_, Int4 &k1_opt_, Int4 &k2_opt_, bool &res_was_calculated_)

static void robust_regression_sum_with_cut_LSM_beta1_is_defined(Int4 min_length_, Int4 number_of_elements_, double *values_, double *errors_, bool cut_left_tail_, bool cut_right_tail_, double y_, double &beta0_, double beta1_, double &beta0_error_, double beta1_error_, Int4 &k1_opt_, Int4 &k2_opt_, bool &res_was_calculated_)

static void find_tetta_general(function_type *func_, void *func_pointer_, double a_, double b_, Int4 n_partition_, double eps_, std::vector< double > &res_)

static double error_of_the_ratio(double v1_, double v1_error_, double v2_, double v2_error_)

static double round_doulbe(double val_, Int4 digits_)

static double function_for_lambda_calculation(double lambda_, void *data_)

void output_main_parameters2m_new(double time_, Int4 nalp, Int4 nalp_for_lambda_simulation, Int4 level, Int4 M_min_, bool &inside_simulation_flag, Int4 final_realizations_number_lambda_, Int4 final_realizations_number_killing_)

array_positive< double > * d_lambda_tmp_errors

void get_minimal_simulation(Int4 ind1_, Int4 ind2_, Int4 &M_min_, Int4 &nalp_, Int4 &nalp_lambda_, bool C_calculation_, bool check_time_flag_)

bool check_K_criterion_during_killing(Int4 ind1_, Int4 ind2_, double lambda_, double eps_K_, Int4 current_level_, Int4 &recommended_level_, Int4 &diff_opt_, double &K_C_, double &K_C_error_)

array_positive< double > * d_C_tmp

bool the_criterion(Int4 upto_nalp_, Int4 &nalp_for_lambda_simulation_, Int4 ind1_, Int4 ind2_, void **&alp_distr, void **&alp_distr_errors, Int4 &M_min_, bool &M_min_flag_, bool &nalp_flag_, bool &inside_simulation_flag_, bool C_calculation_)

static double lambda_exp(Int4 &i_, double *&exp_array_)

static void error_in_calculate_main_parameters2m(double C, double &C_error, double C_mult2, double C_mult2_error)

void randomize_realizations_ind(Int4 ind1_, Int4 ind2_)

static double relative_error_in_percents(double val_, double val_error_)

void kill(bool check_time_, Int4 ind1_, Int4 ind2_, Int4 M_min_, double lambda_, double eps_K_, double &K_C_, double &K_C_error_, Int4 &level_, Int4 &diff_opt_)

vector< double > m_AlphaJSbs

static double get_root(const std::vector< double > &res_tmp_, double point_)

array_positive< alp * > * d_alp_obj

void calculate_C(Int4 starting_point, Int4 nalp_, Int4 ind1_, Int4 ind2_, void **alp_distr, void **alp_distr_errors, double lambda_, double lambda_error_, double &C_, double &C_error_)

void calculate_main_parameters2m(Int4 final_realizations_number_lambda_, Int4 final_realizations_number_killing_, Int4 nalp, Int4 nalp_for_lambda_simulation, Int4 level, bool &inside_simulation_flag, double &lambda, double &lambda_error, double &test_difference, double &test_difference_error, double &C, double &C_error, double &C2, double &C2_error, double &C4, double &C4_error, double &K_C, double &K_C_error, double &a_I, double &a_I_error, double &a_J, double &a_J_error, double &sigma, double &sigma_error, double &alpha_I, double &alpha_I_error, double &alpha_J, double &alpha_J_error, double &K, double &K_error, bool &flag_)

void calculate_lambda(bool check_the_criteria_, Int4 nalp_, Int4 &nalp_thr_, bool &inside_simulation_flag_, Int4 ind1_, Int4 ind2_, void **alp_distr, void **alp_distr_errors, double &lambda_, double &lambda_error_, double &test_difference_, double &test_difference_error_)

void get_and_allocate_alp_distribution(Int4 ind1_, Int4 ind2_, void **&alp_distr, void **&alp_distr_errors, Int4 nalp)

void calculate_FSC(Int4 nalp_, Int4 ind1_, Int4 ind2_, void **alp_distr, void **alp_distr_errors, double lambda_, double lambda_error_, double &a_I_, double &a_I_error_, double &a_J_, double &a_J_error_, double &sigma_, double &sigma_error_, double &alpha_I_, double &alpha_I_error_, double &alpha_J_, double &alpha_J_error_)

void generate_random_permulation(Int4 *perm_, Int4 dim_)

vector< double > m_SigmaSbs

void randomize_realizations(Int4 final_realizations_number_lambda_, Int4 final_realizations_number_killing_)

bool check_K_criterion(Int4 nalp_, Int4 ind1_, Int4 ind2_, double lambda_, double eps_K_, Int4 &M_min_)

vector< double > m_AlphaISbs

void alpha_calculation(double delta_I_aver_, double delta_I_aver_error_, double delta_J_aver_, double delta_J_aver_error_, double delta_E_aver_, double delta_E_aver_error_, double cov_E_E_aver_, double cov_E_E_aver_error_, double cov_I_J_aver_, double cov_I_J_aver_error_, double &alpha_, double &alpha_error_)

alp_sim(alp_data *alp_data_)

vector< double > m_LambdaSbs

static Int4 get_number_of_subsimulations(Int4 number_of_realizations_)

array_positive< double > * d_C_tmp_errors

array_positive< double > * d_lambda_tmp

void get_single_realization(bool check_time_, Int4 M_min_, Int4 nalp_, bool killing_flag_, Int4 level_, Int4 diff_opt_, alp *&obj_, bool &sucess_flag_, double &d_eps_)

void simulate_alp_upto_the_given_level(Int4 M_min_)

void partially_release_memory()

array_positive< Int4 > * d_H_J

array_positive< Int4 > * d_alp

void kill_upto_level(Int4 M_min_, Int4 M_level_)

array_positive< double > * d_alp_weights

bool d_single_realiztion_calculation_flag

array< Int4 > * d_cells_counts

array_positive< Int4 > * d_H_I

void simulate_alp_upto_the_given_number(Int4 nalp_)

void increase_elem_by_x(Int4 ind_, T x_)

void set_elem(Int4 ind_, T elem_)

static const char * expect

int32_t Int4

4-byte (32-bit) signed integer

double lambda(size_t dimMatrix_, const Int4 *const *scoreMatrix_, const double *q_)

double function_type(double x_, void *func_number_)

bool d_calculate_alp_number

void ** d_alp_distr_errors

Int4 d_total_realizations_number_with_ALP

vector< Int4 > d_preliminary_realizations_numbers_ALP

Int4 d_total_realizations_number_with_killing

vector< Int4 > d_preliminary_realizations_numbers_killing

vector< Int4 > d_first_stage_preliminary_realizations_numbers_ALP

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/sls__alp__sim_8cpp_source.html below:

NCBI C++ ToolKit: src/algo/blast/gumbel_params/sls_alp_sim.cpp Source File

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/slsalpsim_8cpp_source.html below: