00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include <cmath>
00019 #include <cstdlib>
00020 #include <fstream>
00021 #include <iostream>
00022 #include <string>
00023 #include <sstream>
00024
00025
00026
00027 #include "independent_parameters.h"
00028
00029 namespace OpenNN
00030 {
00031
00032
00033
00037
00038 IndependentParameters::IndependentParameters(void)
00039 {
00040 set();
00041 }
00042
00043
00044
00045
00051
00052 IndependentParameters::IndependentParameters(const unsigned int& new_parameters_number)
00053 {
00054 set(new_parameters_number);
00055 }
00056
00057
00058
00059
00060
00064
00065 IndependentParameters::IndependentParameters(const IndependentParameters& other_independent_parameters)
00066 {
00067 set(other_independent_parameters);
00068 }
00069
00070
00071
00072
00075
00076 IndependentParameters::~IndependentParameters(void)
00077 {
00078 }
00079
00080
00081
00082
00086
00087 IndependentParameters& IndependentParameters::operator = (const IndependentParameters& other_independent_parameters)
00088 {
00089 if(this != &other_independent_parameters)
00090 {
00091 parameters = other_independent_parameters.parameters;
00092 names = other_independent_parameters.names;
00093 units = other_independent_parameters.units;
00094 descriptions = other_independent_parameters.descriptions;
00095 minimums = other_independent_parameters.minimums;
00096 maximums = other_independent_parameters.maximums;
00097 means = other_independent_parameters.means;
00098 standard_deviations = other_independent_parameters.standard_deviations;
00099 lower_bounds = other_independent_parameters.lower_bounds;
00100 upper_bounds = other_independent_parameters.upper_bounds;
00101 scaling_method = other_independent_parameters.scaling_method;
00102 scaling_flag = other_independent_parameters.scaling_flag;
00103 bounding_flag = other_independent_parameters.bounding_flag;
00104 display_range_warning = other_independent_parameters.display_range_warning;
00105 display = other_independent_parameters.display;
00106 }
00107
00108 return(*this);
00109 }
00110
00111
00112
00113
00114
00115
00120
00121 bool IndependentParameters::operator == (const IndependentParameters& other_independent_parameters) const
00122 {
00123 if(parameters == other_independent_parameters.parameters
00124 && names == other_independent_parameters.names
00125 && units == other_independent_parameters.units
00126 && descriptions == other_independent_parameters.descriptions
00127 && minimums == other_independent_parameters.minimums
00128 && maximums == other_independent_parameters.maximums
00129 && means == other_independent_parameters.means
00130 && standard_deviations == other_independent_parameters.standard_deviations
00131 && lower_bounds == other_independent_parameters.lower_bounds
00132 && upper_bounds == other_independent_parameters.upper_bounds
00133 && scaling_method == other_independent_parameters.scaling_method
00134 && scaling_flag == other_independent_parameters.scaling_flag
00135 && bounding_flag == other_independent_parameters.bounding_flag
00136 && display_range_warning == other_independent_parameters.display_range_warning
00137 && display == other_independent_parameters.display)
00138 {
00139 return(true);
00140 }
00141 else
00142 {
00143 return(false);
00144 }
00145 }
00146
00147
00148
00149
00150
00151
00153
00154 const Vector<double>& IndependentParameters::get_parameters(void) const
00155 {
00156 return(parameters);
00157 }
00158
00159
00160
00161
00164
00165 double IndependentParameters::get_parameter(const unsigned int& index) const
00166 {
00167
00168
00169 #ifdef _DEBUG
00170
00171 const unsigned int parameters_number = count_parameters_number();
00172
00173 if(index >= parameters_number)
00174 {
00175 std::ostringstream buffer;
00176
00177 buffer << "OpenNN Exception: IndependentParameters class.\n"
00178 << "double get_parameter(const unsigned int&) const method.\n"
00179 << "Index of independent parameter must be less than number of parameters.\n";
00180
00181 throw std::logic_error(buffer.str());
00182 }
00183
00184 #endif
00185
00186 return(parameters[index]);
00187 }
00188
00189
00190
00191
00194
00195 const Vector<std::string>& IndependentParameters::get_names(void) const
00196 {
00197 return(names);
00198 }
00199
00200
00201
00202
00206
00207 const std::string& IndependentParameters::get_name(const unsigned int& index) const
00208 {
00209
00210
00211 #ifdef _DEBUG
00212
00213 const unsigned int parameters_number = count_parameters_number();
00214
00215 if(index >= parameters_number)
00216 {
00217 std::ostringstream buffer;
00218
00219 buffer << "OpenNN Exception: IndependentParameters class.\n"
00220 << "const std::string& get_name(const unsigned int&) const method.\n"
00221 << "Index of independent parameter must be less than number of parameters.\n";
00222
00223 throw std::logic_error(buffer.str());
00224 }
00225
00226 #endif
00227
00228 return(names[index]);
00229 }
00230
00231
00232
00233
00236
00237 const Vector<std::string>& IndependentParameters::get_units(void) const
00238 {
00239 return(units);
00240 }
00241
00242
00243
00244
00248
00249 const std::string& IndependentParameters::get_unit(const unsigned int& index) const
00250 {
00251
00252
00253 #ifdef _DEBUG
00254
00255 const unsigned int parameters_number = count_parameters_number();
00256
00257 if(index >= parameters_number)
00258 {
00259 std::ostringstream buffer;
00260
00261 buffer << "OpenNN Exception: IndependentParameters class.\n"
00262 << "const std::string get_units(const unsigned int&) const method.\n"
00263 << "Index of independent parameter must be less than number of parameters.\n";
00264
00265 throw std::logic_error(buffer.str());
00266 }
00267
00268 #endif
00269
00270 return(units[index]);
00271 }
00272
00273
00274
00275
00278
00279 const Vector<std::string>& IndependentParameters::get_descriptions(void) const
00280 {
00281 return(descriptions);
00282 }
00283
00284
00285
00286
00290
00291 const std::string& IndependentParameters::get_description(const unsigned int& index) const
00292 {
00293
00294
00295 #ifdef _DEBUG
00296
00297 const unsigned int parameters_number = count_parameters_number();
00298
00299 if(index >= parameters_number)
00300 {
00301 std::ostringstream buffer;
00302
00303 buffer << "OpenNN Exception: IndependentParameters class.\n"
00304 << "const std::string get_description(const unsigned int&) const method.\n"
00305 << "Index of independent parameter must be less than number of parameters.\n";
00306
00307 throw std::logic_error(buffer.str());
00308 }
00309
00310 #endif
00311
00312 return(descriptions[index]);
00313 }
00314
00315
00316
00317
00325
00326 Vector< Vector<std::string> > IndependentParameters::arrange_information(void)
00327 {
00328 Vector< Vector<std::string> > information(3);
00329
00330 information[0] = names;
00331 information[1] = units;
00332 information[2] = descriptions;
00333
00334 return(information);
00335 }
00336
00337
00338
00339
00342
00343 const Vector<double>& IndependentParameters::get_minimums(void) const
00344 {
00345 return(minimums);
00346 }
00347
00348
00349
00350
00354
00355 double IndependentParameters::get_minimum(const unsigned int& index) const
00356 {
00357
00358
00359 #ifdef _DEBUG
00360
00361 const unsigned int parameters_number = count_parameters_number();
00362
00363 if(index >= parameters_number)
00364 {
00365 std::ostringstream buffer;
00366
00367 buffer << "OpenNN Exception: IndependentParameters class.\n"
00368 << "double get_minimum(const unsigned int&) const method.\n"
00369 << "Index of independent parameter must be less than number of parameters.\n";
00370
00371 throw std::logic_error(buffer.str());
00372 }
00373
00374 #endif
00375
00376 return(minimums[index]);
00377 }
00378
00379
00380
00381
00385
00386 const Vector<double>& IndependentParameters::get_maximums(void) const
00387 {
00388 return(maximums);
00389 }
00390
00391
00392
00393
00397
00398 double IndependentParameters::get_maximum(const unsigned int& index) const
00399 {
00400
00401
00402 #ifdef _DEBUG
00403
00404 const unsigned int parameters_number = count_parameters_number();
00405
00406 if(index >= parameters_number)
00407 {
00408 std::ostringstream buffer;
00409
00410 buffer << "OpenNN Exception: IndependentParameters class.\n"
00411 << "double get_maximum(const unsigned int&) const method.\n"
00412 << "Index must be less than number of parameters.\n";
00413
00414 throw std::logic_error(buffer.str());
00415 }
00416
00417 #endif
00418
00419 return(maximums[index]);
00420 }
00421
00422
00423
00424
00427
00428 const Vector<double>& IndependentParameters::get_means(void) const
00429 {
00430 return(means);
00431 }
00432
00433
00434
00435
00439
00440 double IndependentParameters::get_mean(const unsigned int& index) const
00441 {
00442
00443
00444 #ifdef _DEBUG
00445
00446 const unsigned int parameters_number = count_parameters_number();
00447
00448 if(index >= parameters_number)
00449 {
00450 std::ostringstream buffer;
00451
00452 buffer << "OpenNN Exception: IndependentParameters class.\n"
00453 << "double get_mean(const unsigned int&) const method.\n"
00454 << "Index must be less than number of parameters.\n";
00455
00456 throw std::logic_error(buffer.str());
00457 }
00458
00459 #endif
00460
00461 return(means[index]);
00462 }
00463
00464
00465
00466
00469
00470 const Vector<double>& IndependentParameters::get_standard_deviations(void) const
00471 {
00472 return(standard_deviations);
00473 }
00474
00475
00476
00477
00481
00482 double IndependentParameters::get_standard_deviation(const unsigned int& index) const
00483 {
00484
00485
00486 #ifdef _DEBUG
00487
00488 const unsigned int parameters_number = count_parameters_number();
00489
00490 if(index >= parameters_number)
00491 {
00492 std::ostringstream buffer;
00493
00494 buffer << "OpenNN Exception: IndependentParameters class.\n"
00495 << "double get_standard_deviation(const unsigned int&) const method.\n"
00496 << "Index must be less than number of parameters.\n";
00497
00498 throw std::logic_error(buffer.str());
00499 }
00500
00501 #endif
00502
00503 return(standard_deviations[index]);
00504 }
00505
00506
00507
00508
00514
00515 Vector< Vector<double> > IndependentParameters::arrange_minimums_maximums(void)
00516 {
00517 Vector< Vector<double> > minimums_maximums(2);
00518
00519 minimums_maximums[0] = minimums;
00520 minimums_maximums[1] = maximums;
00521
00522 return(minimums_maximums);
00523 }
00524
00525
00526
00527
00532
00533 Vector< Vector<double> > IndependentParameters::arrange_means_standard_deviations(void)
00534 {
00535 Vector< Vector<double> > means_standard_deviations(2);
00536
00537 means_standard_deviations[0] = means;
00538 means_standard_deviations[1] = standard_deviations;
00539
00540 return(means_standard_deviations);
00541 }
00542
00543
00544
00545
00548
00549 Vector< Vector<double> > IndependentParameters::arrange_statistics(void)
00550 {
00551 Vector< Vector<double> > statistics(4);
00552
00553 statistics[0] = minimums;
00554 statistics[1] = minimums;
00555 statistics[2] = means;
00556 statistics[3] = standard_deviations;
00557
00558 return(statistics);
00559 }
00560
00561
00562
00563
00565
00566 const IndependentParameters::ScalingMethod& IndependentParameters::get_scaling_method(void) const
00567 {
00568 return(scaling_method);
00569 }
00570
00571
00572
00573
00575
00576 std::string IndependentParameters::write_scaling_method(void) const
00577 {
00578 if(scaling_method == MeanStandardDeviation)
00579 {
00580 return("MeanStandardDeviation");
00581 }
00582 else if(scaling_method == MinimumMaximum)
00583 {
00584 return("MinimumMaximum");
00585 }
00586 else
00587 {
00588 std::ostringstream buffer;
00589
00590 buffer << "OpenNN Exception: IndependentParameters class.\n"
00591 << "std::string write_scaling_method(void) const method.\n"
00592 << "Unknown scaling and unscaling method.\n";
00593
00594 throw std::logic_error(buffer.str());
00595 }
00596 }
00597
00598
00599
00600
00602
00603 const bool& IndependentParameters::get_scaling_flag(void) const
00604 {
00605 return(scaling_flag);
00606 }
00607
00608
00609
00610
00613
00614 const Vector<double>& IndependentParameters::get_lower_bounds(void) const
00615 {
00616 return(lower_bounds);
00617 }
00618
00619
00620
00621
00625
00626 double IndependentParameters::get_lower_bound(const unsigned int& index) const
00627 {
00628
00629
00630 #ifdef _DEBUG
00631
00632 const unsigned int parameters_number = count_parameters_number();
00633
00634 if(index >= parameters_number)
00635 {
00636 std::ostringstream buffer;
00637
00638 buffer << "OpenNN Exception: IndependentParameters class.\n"
00639 << "double get_lower_bound(const unsigned int&) const method.\n"
00640 << "Index must be less than number of parameters.\n";
00641
00642 throw std::logic_error(buffer.str());
00643 }
00644
00645 #endif
00646
00647 return(lower_bounds[index]);
00648 }
00649
00650
00651
00652
00655
00656 const Vector<double>& IndependentParameters::get_upper_bounds(void) const
00657 {
00658 return(upper_bounds);
00659 }
00660
00661
00662
00663
00667
00668 double IndependentParameters::get_upper_bound(const unsigned int& index) const
00669 {
00670
00671
00672 #ifdef _DEBUG
00673
00674 const unsigned int parameters_number = count_parameters_number();
00675
00676 if(index >= parameters_number)
00677 {
00678 std::ostringstream buffer;
00679
00680 buffer << "OpenNN Exception: IndependentParameters class.\n"
00681 << "double get_upper_bound(const unsigned int&) const method.\n"
00682 << "Index must be less than number of parameters.\n";
00683
00684 throw std::logic_error(buffer.str());
00685 }
00686
00687 #endif
00688
00689 return(upper_bounds[index]);
00690 }
00691
00692
00693
00694
00701
00702 Vector< Vector<double>* > IndependentParameters::get_bounds(void)
00703 {
00704 Vector< Vector<double>* > bounds(2);
00705
00706 bounds[0] = &lower_bounds;
00707 bounds[1] = &upper_bounds;
00708
00709 return(bounds);
00710 }
00711
00712
00713
00714
00716
00717 bool IndependentParameters::get_bounding_flag(void) const
00718 {
00719 return(bounding_flag);
00720 }
00721
00722
00723
00724
00727
00728 const bool& IndependentParameters::get_display(void) const
00729 {
00730 return(display);
00731 }
00732
00733
00734
00735
00738
00739 void IndependentParameters::set(void)
00740 {
00741 set_parameters_number(0);
00742
00743 set_default();
00744 }
00745
00746
00747
00748
00752
00753 void IndependentParameters::set(const unsigned int& new_parameters_number)
00754 {
00755 set_parameters_number(new_parameters_number);
00756
00757 set_default();
00758 }
00759
00760
00761
00762
00766
00767 void IndependentParameters::set(const Vector<double>& new_parameters)
00768 {
00769 const unsigned int new_parameters_number = new_parameters.size();
00770
00771 set_parameters_number(new_parameters_number);
00772
00773 parameters = new_parameters;
00774
00775 set_default();
00776 }
00777
00778
00779
00780
00783
00784 void IndependentParameters::set(const IndependentParameters& other_independent_parameters)
00785 {
00786 parameters = other_independent_parameters.parameters;
00787
00788 names = other_independent_parameters.names;
00789
00790 units = other_independent_parameters.units;
00791
00792 descriptions = other_independent_parameters.descriptions;
00793
00794 minimums = other_independent_parameters.minimums;
00795
00796 maximums = other_independent_parameters.maximums;
00797
00798 means = other_independent_parameters.means;
00799
00800 standard_deviations = other_independent_parameters.standard_deviations;
00801
00802 lower_bounds = other_independent_parameters.lower_bounds;
00803
00804 upper_bounds = other_independent_parameters.upper_bounds;
00805
00806 scaling_method = other_independent_parameters.scaling_method;
00807
00808 scaling_flag = other_independent_parameters.scaling_flag;
00809
00810 bounding_flag = other_independent_parameters.bounding_flag;
00811
00812 display_range_warning = other_independent_parameters.display_range_warning;
00813
00814 display = other_independent_parameters.display;
00815 }
00816
00817
00818
00819
00821
00822 void IndependentParameters::set_default(void)
00823 {
00824 set_scaling_method(MinimumMaximum);
00825
00826 scaling_flag = false;
00827
00828 bounding_flag = false;
00829
00830 set_display(true);
00831 }
00832
00833
00834
00835
00838
00839 void IndependentParameters::set_parameters_number(const unsigned int& new_parameters_number)
00840 {
00841 parameters.set(new_parameters_number, 0.0);
00842
00843 names.set(new_parameters_number);
00844
00845 units.set(new_parameters_number);
00846
00847 descriptions.set(new_parameters_number);
00848
00849 minimums.set(new_parameters_number, -1.0);
00850
00851 maximums.set(new_parameters_number, 1.0);
00852
00853 means.set(new_parameters_number, 0.0);
00854
00855 standard_deviations.set(new_parameters_number, 1.0);
00856
00857 lower_bounds.set(new_parameters_number, -1.0e99);
00858
00859 upper_bounds.set(new_parameters_number, 1.0e99);
00860 }
00861
00862
00863
00864
00867
00868 void IndependentParameters::set_parameters(const Vector<double>& new_parameters)
00869 {
00870
00871
00872 #ifdef _DEBUG
00873
00874 const unsigned int parameters_number = count_parameters_number();
00875
00876 if(new_parameters.size() != parameters_number)
00877 {
00878 std::ostringstream buffer;
00879
00880 buffer << "OpenNN Exception: IndependentParameters class.\n"
00881 << "void set_parameters(const Vector<double>&) method.\n"
00882 << "Parameters size must be equal to number of parameters.\n";
00883
00884 throw std::logic_error(buffer.str());
00885 }
00886
00887 #endif
00888
00889 parameters = new_parameters;
00890
00891 if(bounding_flag)
00892 {
00893 bound_parameters();
00894 }
00895 }
00896
00897
00898
00899
00903
00904 void IndependentParameters::set_parameter(const unsigned int& index, const double& new_parameter)
00905 {
00906
00907
00908 #ifdef _DEBUG
00909
00910 const unsigned int parameters_number = count_parameters_number();
00911
00912 if(index >= parameters_number)
00913 {
00914 std::ostringstream buffer;
00915
00916 buffer << "OpenNN Exception: IndependentParameters class.\n"
00917 << "void set_parameter(const unsigned int&, const double&) method.\n"
00918 << "Index must be less than number of parameters.\n";
00919
00920 throw std::logic_error(buffer.str());
00921 }
00922
00923 #endif
00924
00925 parameters[index] = new_parameter;
00926
00927 bound_parameter(index);
00928 }
00929
00930
00931
00932
00936
00937 void IndependentParameters::set_names(const Vector<std::string>& new_names)
00938 {
00939
00940
00941 #ifdef _DEBUG
00942
00943 const unsigned int parameters_number = count_parameters_number();
00944
00945 if(new_names.size() != parameters_number)
00946 {
00947 std::ostringstream buffer;
00948
00949 buffer << "OpenNN Exception: IndependentParameters class.\n"
00950 << "void set_name(const Vector<std::string>&) method.\n"
00951 << "Size of names must be equal to number of parameters.\n";
00952
00953 throw std::logic_error(buffer.str());
00954 }
00955
00956 #endif
00957
00958
00959
00960 names = new_names;
00961 }
00962
00963
00964
00965
00970
00971 void IndependentParameters::set_name(const unsigned int& index, const std::string& new_name)
00972 {
00973
00974
00975 const unsigned int parameters_number = count_parameters_number();
00976
00977 #ifdef _DEBUG
00978
00979 if(index >= parameters_number)
00980 {
00981 std::ostringstream buffer;
00982
00983 buffer << "OpenNN Exception: IndependentParameters class.\n"
00984 << "void set_name(const unsigned int&, const std::string&) method.\n"
00985 << "Index must be less than number of parameters.\n";
00986
00987 throw std::logic_error(buffer.str());
00988 }
00989
00990 #endif
00991
00992 if(names.size() != parameters_number)
00993 {
00994 names.set(parameters_number);
00995 }
00996
00997
00998
00999 names[index] = new_name;
01000 }
01001
01002
01003
01004
01008
01009 void IndependentParameters::set_units(const Vector<std::string>& new_units)
01010 {
01011
01012
01013 #ifdef _DEBUG
01014
01015 const unsigned int parameters_number = count_parameters_number();
01016
01017 if(new_units.size() != parameters_number)
01018 {
01019 std::ostringstream buffer;
01020
01021 buffer << "OpenNN Exception: IndependentParameters class.\n"
01022 << "void set_units(const Vector<std::string>&) method.\n"
01023 << "Size must be equal to number of parameters.\n";
01024
01025 throw std::logic_error(buffer.str());
01026 }
01027
01028 #endif
01029
01030
01031
01032 units = new_units;
01033 }
01034
01035
01036
01037
01042
01043 void IndependentParameters::set_unit(const unsigned int& index, const std::string& new_unit)
01044 {
01045 const unsigned int parameters_number = count_parameters_number();
01046
01047
01048
01049 #ifdef _DEBUG
01050
01051 if(index >= parameters_number)
01052 {
01053 std::ostringstream buffer;
01054
01055 buffer << "OpenNN Exception: IndependentParameters class.\n"
01056 << "void set_unit(const unsigned int&, const std::string&) method.\n"
01057 << "Index of independent parameter must be less than number of parameters.\n";
01058
01059 throw std::logic_error(buffer.str());
01060 }
01061
01062 #endif
01063
01064 if(units.size() == 0)
01065 {
01066 units.set(parameters_number);
01067 }
01068
01069
01070
01071 units[index] = new_unit;
01072 }
01073
01074
01075
01076
01080
01081 void IndependentParameters::set_descriptions(const Vector<std::string>& new_descriptions)
01082 {
01083
01084
01085 #ifdef _DEBUG
01086
01087 const unsigned int parameters_number = count_parameters_number();
01088
01089 if(new_descriptions.size() != parameters_number)
01090 {
01091 std::ostringstream buffer;
01092
01093 buffer << "OpenNN Exception: IndependentParameters class.\n"
01094 << "void set_descriptions(const Vector<std::string>&) method.\n"
01095 << "Size of descriptions must be equal to number of parameters.\n";
01096
01097 throw std::logic_error(buffer.str());
01098 }
01099
01100 #endif
01101
01102 descriptions = new_descriptions;
01103 }
01104
01105
01106
01107
01112
01113 void IndependentParameters::set_description(const unsigned int& index, const std::string& new_description)
01114 {
01115 const unsigned int parameters_number = count_parameters_number();
01116
01117
01118
01119 #ifdef _DEBUG
01120
01121 if(index >= parameters_number)
01122 {
01123 std::ostringstream buffer;
01124
01125 buffer << "OpenNN Exception: IndependentParameters class.\n"
01126 << "void set_description(const unsigned int&, const std::string&) method.\n"
01127 << "Index must be less than number of parameters.\n";
01128
01129 throw std::logic_error(buffer.str());
01130 }
01131
01132 #endif
01133
01134 if(descriptions.size() == 0)
01135 {
01136 descriptions.set(parameters_number);
01137 }
01138
01139
01140
01141 descriptions[index] = new_description;
01142 }
01143
01144
01145
01146
01150
01151 void IndependentParameters::set_minimums(const Vector<double>& new_minimums)
01152 {
01153
01154
01155 #ifdef _DEBUG
01156
01157 const unsigned int parameters_number = count_parameters_number();
01158
01159 if(new_minimums.size() != parameters_number)
01160 {
01161 std::ostringstream buffer;
01162
01163 buffer << "OpenNN Exception: IndependentParameters class.\n"
01164 << "void set_minimums(const Vector<double>&) method.\n"
01165 << "Size of minimums must be equal to number of parameters.\n";
01166
01167 throw std::logic_error(buffer.str());
01168 }
01169
01170 #endif
01171
01172
01173
01174 minimums = new_minimums;
01175 }
01176
01177
01178
01179
01184
01185 void IndependentParameters::set_minimum(const unsigned int& index, const double& new_minimum)
01186 {
01187 const unsigned int parameters_number = count_parameters_number();
01188
01189
01190
01191 #ifdef _DEBUG
01192
01193 if(index >= parameters_number)
01194 {
01195 std::ostringstream buffer;
01196
01197 buffer << "OpenNN Exception: IndependentParameters class.\n"
01198 << "void set_minimum(const unsigned int&, const double&) method.\n"
01199 << "Index of independent parameter must be less than number of parameters.\n";
01200
01201 throw std::logic_error(buffer.str());
01202 }
01203
01204 #endif
01205
01206 if(minimums.size() != parameters_number)
01207 {
01208 minimums.set(parameters_number, -1.0);
01209 }
01210
01211
01212
01213 minimums[index] = new_minimum;
01214 }
01215
01216
01217
01218
01222
01223 void IndependentParameters::set_maximums(const Vector<double>& new_maximums)
01224 {
01225
01226
01227 #ifdef _DEBUG
01228
01229 const unsigned int parameters_number = count_parameters_number();
01230
01231 if(new_maximums.size() != parameters_number)
01232 {
01233 std::ostringstream buffer;
01234
01235 buffer << "OpenNN Exception: IndependentParameters class.\n"
01236 << "void set_maximum(const Vector<double>&) method.\n"
01237 << "Size of maximums must be equal to number of parameters.\n";
01238
01239 throw std::logic_error(buffer.str());
01240 }
01241
01242 #endif
01243
01244
01245
01246 maximums = new_maximums;
01247 }
01248
01249
01250
01251
01256
01257 void IndependentParameters::set_maximum(const unsigned int& index, const double& new_maximum)
01258 {
01259 const unsigned int parameters_number = count_parameters_number();
01260
01261
01262
01263 #ifdef _DEBUG
01264
01265 if(index >= parameters_number)
01266 {
01267 std::ostringstream buffer;
01268
01269 buffer << "OpenNN Exception: IndependentParameters class.\n"
01270 << "void set_maximum(const unsigned& int, const double&) method.\n"
01271 << "Index must be less than number of parameters.\n";
01272
01273 throw std::logic_error(buffer.str());
01274 }
01275
01276 #endif
01277
01278
01279
01280 if(maximums.size() != parameters_number)
01281 {
01282 maximums.set(parameters_number, 1.0);
01283 }
01284
01285
01286
01287 maximums[index] = new_maximum;
01288 }
01289
01290
01291
01292
01296
01297 void IndependentParameters::set_means(const Vector<double>& new_means)
01298 {
01299
01300
01301 #ifdef _DEBUG
01302
01303 const unsigned int parameters_number = count_parameters_number();
01304
01305 if(new_means.size() != parameters_number)
01306 {
01307 std::ostringstream buffer;
01308
01309 buffer << "OpenNN Exception: IndependentParameters class.\n"
01310 << "void set_means(const Vector<double>&) method.\n"
01311 << "Size must be equal to number of parameters.\n";
01312
01313 throw std::logic_error(buffer.str());
01314 }
01315
01316 #endif
01317
01318
01319
01320 means = new_means;
01321 }
01322
01323
01324
01325
01330
01331 void IndependentParameters::set_mean(const unsigned int& index, const double& new_mean)
01332 {
01333 const unsigned int parameters_number = count_parameters_number();
01334
01335
01336
01337 #ifdef _DEBUG
01338
01339 if(index >= parameters_number)
01340 {
01341 std::ostringstream buffer;
01342
01343 buffer << "OpenNN Exception: IndependentParameters class.\n"
01344 << "void set_mean(const unsigned int&, const double&) method.\n"
01345 << "Index of must be less than number of parameters.\n";
01346
01347 throw std::logic_error(buffer.str());
01348 }
01349
01350 #endif
01351
01352
01353
01354 const unsigned int size = means.size();
01355
01356 if(size != parameters_number)
01357 {
01358 means.set(parameters_number, 0.0);
01359 }
01360
01361
01362
01363 means[index] = new_mean;
01364 }
01365
01366
01367
01368
01372
01373 void IndependentParameters::set_standard_deviations(const Vector<double>& new_standard_deviations)
01374 {
01375
01376
01377 #ifdef _DEBUG
01378
01379 const unsigned int parameters_number = count_parameters_number();
01380
01381 if(new_standard_deviations.size() != parameters_number)
01382 {
01383 std::ostringstream buffer;
01384
01385 buffer << "OpenNN Exception: IndependentParameters class.\n"
01386 << "void set_standard_deviations(const Vector<double>&) method.\n"
01387 << "Size must be equal to number of parameters.\n";
01388
01389 throw std::logic_error(buffer.str());
01390 }
01391
01392 #endif
01393
01394
01395
01396 standard_deviations = new_standard_deviations;
01397 }
01398
01399
01400
01401
01406
01407 void IndependentParameters::set_standard_deviation(const unsigned int& index, const double& new_standard_deviation)
01408 {
01409 const unsigned int parameters_number = count_parameters_number();
01410
01411
01412
01413 #ifdef _DEBUG
01414
01415 if(index >= parameters_number)
01416 {
01417 std::ostringstream buffer;
01418
01419 buffer << "OpenNN Exception: IndependentParameters class.\n"
01420 << "void set_standard_deviation(const unsigned int&, const double&) method.\n"
01421 << "Index must be less than number of parameters.\n";
01422
01423 throw std::logic_error(buffer.str());
01424 }
01425
01426 #endif
01427
01428
01429
01430 const unsigned int size = standard_deviations.size();
01431
01432 if(size != parameters_number)
01433 {
01434 standard_deviations.set(parameters_number, 1.0);
01435 }
01436
01437
01438
01439 standard_deviations[index] = new_standard_deviation;
01440 }
01441
01442
01443
01444
01451
01452 void IndependentParameters::set_minimums_maximums(const Vector< Vector<double> >& new_minimums_maximums)
01453 {
01454
01455
01456 #ifdef _DEBUG
01457
01458 const unsigned int parameters_number = count_parameters_number();
01459
01460 if(new_minimums_maximums.size() != 2)
01461 {
01462 std::ostringstream buffer;
01463
01464 buffer << "OpenNN Exception: IndependentParameters class.\n"
01465 << "void set_minimum_maximum(const Vector< Vector<double> >&) method.\n"
01466 << "Number of rows must be 2.\n";
01467
01468 throw std::logic_error(buffer.str());
01469 }
01470 else if(new_minimums_maximums[0].size() != parameters_number
01471 && new_minimums_maximums[1].size() != parameters_number)
01472 {
01473 std::ostringstream buffer;
01474
01475 buffer << "OpenNN Exception: IndependentParameters class.\n"
01476 << "void set_minimum_maximum(const Vector< Vector<double> >&) method.\n"
01477 << "Number of columns must be equal to number of parameters.\n";
01478
01479 throw std::logic_error(buffer.str());
01480 }
01481
01482
01483
01484 for(unsigned int i = 0; i < parameters_number; i++)
01485 {
01486 if(new_minimums_maximums[0][i] >= new_minimums_maximums[1][i])
01487 {
01488 std::ostringstream buffer;
01489
01490 buffer << "OpenNN Exception: IndependentParameters class.\n"
01491 << "void set_minimums_maximums(const Vector< Vector<double> >&) method.\n"
01492 << "Minimum of parameter "<< i << " is equal or greater than maximum of that parameter.\n";
01493
01494 throw std::logic_error(buffer.str());
01495 }
01496 }
01497
01498 #endif
01499
01500
01501
01502 minimums = new_minimums_maximums[0];
01503 maximums = new_minimums_maximums[1];
01504 }
01505
01506
01507
01508
01515
01516 void IndependentParameters::set_means_standard_deviations(const Vector< Vector<double> >& new_means_standard_deviations)
01517 {
01518
01519
01520 #ifdef _DEBUG
01521
01522 std::ostringstream buffer;
01523
01524 const unsigned int parameters_number = count_parameters_number();
01525
01526 const unsigned int size = new_means_standard_deviations.size();
01527
01528 if(size != 2)
01529 {
01530 buffer << "OpenNN Exception: IndependentParameters class.\n"
01531 << "void set_means_standard_deviations(const Vector< Vector<double> >& ) method.\n"
01532 << "Number of rows must be 2.\n";
01533
01534 throw std::logic_error(buffer.str());
01535 }
01536 else if(new_means_standard_deviations[0].size() != parameters_number
01537 && new_means_standard_deviations[1].size() != parameters_number)
01538 {
01539 buffer << "OpenNN Exception: IndependentParameters class.\n"
01540 << "void set_means_standard_deviations(const Vector< Vector<double> >& ) method.\n"
01541 << "Number of columns must be equal to number of parameters.\n";
01542
01543 throw std::logic_error(buffer.str());
01544 }
01545
01546
01547
01548 if(display)
01549 {
01550 for(unsigned int i = 0; i < parameters_number; i++)
01551 {
01552 if(new_means_standard_deviations[1][i] < 1.0e-99)
01553 {
01554 std::ostringstream buffer;
01555
01556 buffer << "OpenNN Exception: IndependentParameters class: \n"
01557 << "void set_means_standard_deviations(const Vector< Vector<double> >& ) method.\n"
01558 << "Standard deviation of independent parameter " << i << " is zero.\n";
01559 }
01560 }
01561 }
01562
01563 #endif
01564
01565
01566
01567 means = new_means_standard_deviations[0];
01568 standard_deviations = new_means_standard_deviations[1];
01569 }
01570
01571
01572
01573
01583
01584 void IndependentParameters::set_statistics(const Vector< Vector<double> >& new_statistics)
01585 {
01586
01587
01588 #ifdef _DEBUG
01589
01590 if(new_statistics.size() != 4)
01591 {
01592 std::ostringstream buffer;
01593
01594 buffer << "OpenNN Exception: IndependentParameters class.\n"
01595 << "void set_statistics(const Vector< Vector<double> >&) method.\n"
01596 << "Size must be 6.\n";
01597
01598 throw std::logic_error(buffer.str());
01599 }
01600
01601 #endif
01602
01603
01604
01605 set_minimums(new_statistics[0]);
01606 set_maximums(new_statistics[1]);
01607
01608 set_means(new_statistics[2]);
01609 set_standard_deviations(new_statistics[3]);
01610
01611 }
01612
01613
01614
01615
01618
01619 void IndependentParameters::set_scaling_method
01620 (const IndependentParameters::ScalingMethod& new_scaling_method)
01621 {
01622 scaling_method = new_scaling_method;
01623 }
01624
01625
01626
01627
01631
01632 void IndependentParameters::set_scaling_method(const std::string& new_scaling_method)
01633 {
01634 if(new_scaling_method == "MeanStandardDeviation")
01635 {
01636 set_scaling_method(MeanStandardDeviation);
01637 }
01638 else if(new_scaling_method == "MinimumMaximum")
01639 {
01640 set_scaling_method(MinimumMaximum);
01641 }
01642 else
01643 {
01644 std::ostringstream buffer;
01645
01646 buffer << "OpenNN Exception: IndependentParameters class.\n"
01647 << "void set_scaling_method(const std::string&) method.\n"
01648 << "Unknown independent parameters scaling method: " << new_scaling_method << ".\n";
01649
01650 throw std::logic_error(buffer.str());
01651 }
01652 }
01653
01654
01655
01656
01659
01660 void IndependentParameters::set_scaling_flag(const bool& new_scaling_flag)
01661 {
01662 scaling_flag = new_scaling_flag;
01663 }
01664
01665
01666
01667
01669
01670 void IndependentParameters::set_lower_bounds(void)
01671 {
01672 const unsigned int parameters_number = count_parameters_number();
01673
01674 lower_bounds.set(parameters_number, 1.0e-99);
01675 }
01676
01677
01678
01679
01683
01684 void IndependentParameters::set_lower_bounds(const Vector<double>& new_lower_bounds)
01685 {
01686
01687
01688 #ifdef _DEBUG
01689
01690 const unsigned int parameters_number = count_parameters_number();
01691
01692 if(new_lower_bounds.size() != parameters_number)
01693 {
01694 std::ostringstream buffer;
01695
01696 buffer << "OpenNN Exception: IndependentParameters class.\n"
01697 << "void set_lower_bounds(const Vector<double>&) method.\n"
01698 << "Size must be equal to number of parameters.\n";
01699
01700 throw std::logic_error(buffer.str());
01701 }
01702
01703 #endif
01704
01705
01706
01707 lower_bounds = new_lower_bounds;
01708 }
01709
01710
01711
01712
01717
01718 void IndependentParameters::set_lower_bound(const unsigned int& index, const double& new_lower_bound)
01719 {
01720 const unsigned int parameters_number = count_parameters_number();
01721
01722
01723
01724 #ifdef _DEBUG
01725
01726 if(index >= parameters_number)
01727 {
01728 std::ostringstream buffer;
01729
01730 buffer << "OpenNN Exception: IndependentParameters class.\n"
01731 << "void set_lower_bound(const unsigned int&, const double&) method.\n"
01732 << "Index must be less than number of parameters.\n";
01733
01734 throw std::logic_error(buffer.str());
01735 }
01736
01737 #endif
01738
01739
01740
01741 if(lower_bounds.size() != parameters_number)
01742 {
01743 lower_bounds.set(parameters_number, -1.0e99);
01744 }
01745
01746
01747
01748 lower_bounds[index] = new_lower_bound;
01749 }
01750
01751
01752
01753
01755
01756 void IndependentParameters::set_upper_bounds(void)
01757 {
01758 const unsigned int parameters_number = count_parameters_number();
01759
01760 upper_bounds.set(parameters_number, 1.0e99);
01761 }
01762
01763
01764
01765
01770
01771 void IndependentParameters::set_upper_bounds(const Vector<double>& new_upper_bounds)
01772 {
01773
01774
01775 #ifdef _DEBUG
01776
01777 const unsigned int parameters_number = count_parameters_number();
01778
01779 if(new_upper_bounds.size() != parameters_number)
01780 {
01781 std::ostringstream buffer;
01782
01783 buffer << "OpenNN Exception: IndependentParameters class.\n"
01784 << "void set_upper_bound(const Vector<double>&) method.\n"
01785 << "Size of upper bounds must be equal to number of parameters.\n";
01786
01787 throw std::logic_error(buffer.str());
01788 }
01789
01790 #endif
01791
01792 upper_bounds = new_upper_bounds;
01793 }
01794
01795
01796
01797
01802
01803 void IndependentParameters::set_upper_bound(const unsigned int& index, const double& new_upper_bound)
01804 {
01805
01806
01807 #ifdef _DEBUG
01808
01809 const unsigned int parameters_number = count_parameters_number();
01810
01811 if(index >= parameters_number)
01812 {
01813 std::ostringstream buffer;
01814
01815 buffer << "OpenNN Exception: IndependentParameters class.\n"
01816 << "void set_upper_bound(const unsigned int&, const double&) method.\n"
01817 << "Index must be less than number of parameters.\n";
01818
01819 throw std::logic_error(buffer.str());
01820 }
01821
01822 #endif
01823
01824 upper_bounds[index] = new_upper_bound;
01825 }
01826
01827
01828
01829
01831
01832 void IndependentParameters::set_bounds(void)
01833 {
01834 set_lower_bounds();
01835 set_upper_bounds();
01836 }
01837
01838
01839
01840
01848
01849 void IndependentParameters::set_bounds(const Vector< Vector<double> >& new_bounds)
01850 {
01851
01852
01853 #ifdef _DEBUG
01854
01855 const unsigned int parameters_number = count_parameters_number();
01856
01857 if(new_bounds.size() != 2)
01858 {
01859 std::ostringstream buffer;
01860
01861 buffer << "OpenNN Exception: IndependentParameters class.\n"
01862 << "void set_bounds(const Vector< Vector<double> >&) method.\n"
01863 << "Number of rows must be 2.\n";
01864
01865 throw std::logic_error(buffer.str());
01866 }
01867
01868
01869 if(new_bounds[0].size() != parameters_number
01870 && new_bounds[1].size() != parameters_number)
01871 {
01872 std::ostringstream buffer;
01873
01874 buffer << "OpenNN Exception: IndependentParameters class.\n"
01875 << "void set_bounds(const Vector< Vector<double> >&) method.\n"
01876 << "Number of columns must be equal to number of parameters.\n";
01877
01878 throw std::logic_error(buffer.str());
01879 }
01880
01881 #endif
01882
01883
01884
01885 lower_bounds = new_bounds[0];
01886 upper_bounds = new_bounds[1];
01887 }
01888
01889
01890
01891
01894
01895 void IndependentParameters::set_bounding_flag(const bool& new_bounding_flag)
01896 {
01897 bounding_flag = new_bounding_flag;
01898 }
01899
01900
01901
01902
01907
01908 void IndependentParameters::set_display(const bool& new_display)
01909 {
01910 display = new_display;
01911 }
01912
01913
01914
01915
01917
01918 bool IndependentParameters::is_empty(void) const
01919 {
01920 if(parameters.empty())
01921 {
01922 return(true);
01923 }
01924 else
01925 {
01926 return(false);
01927 }
01928 }
01929
01930
01931
01932
01935
01936 void IndependentParameters::initialize_parameters(const double& value)
01937 {
01938 parameters.initialize(value);
01939
01940 if(bounding_flag)
01941 {
01942 bound_parameters();
01943 }
01944 }
01945
01946
01947
01948
01950
01951 void IndependentParameters::initialize_parameters_uniform(void)
01952 {
01953 parameters.initialize_uniform();
01954
01955 if(bounding_flag)
01956 {
01957 bound_parameters();
01958 }
01959 }
01960
01961
01962
01963
01967
01968 void IndependentParameters::initialize_parameters_uniform(const double& minimum, const double& maximum)
01969 {
01970 parameters.initialize_uniform(minimum, maximum);
01971
01972 if(bounding_flag)
01973 {
01974 bound_parameters();
01975 }
01976 }
01977
01978
01979
01980
01985
01986 void IndependentParameters::initialize_parameters_uniform(const Vector<double>& minimum, const Vector<double>& maximum)
01987 {
01988 parameters.initialize_uniform(minimum, maximum);
01989
01990 if(bounding_flag)
01991 {
01992 bound_parameters();
01993 }
01994 }
01995
01996
01997
01998
02005
02006 void IndependentParameters::initialize_parameters_uniform(const Vector< Vector<double> >& minimum_maximum)
02007 {
02008 parameters.initialize_uniform(minimum_maximum[0], minimum_maximum[1]);
02009
02010 if(bounding_flag)
02011 {
02012 bound_parameters();
02013 }
02014 }
02015
02016
02017
02018
02021
02022 void IndependentParameters::initialize_parameters_normal(void)
02023 {
02024 parameters.initialize_normal();
02025
02026 if(bounding_flag)
02027 {
02028 bound_parameters();
02029 }
02030 }
02031
02032
02033
02034
02039
02040 void IndependentParameters::initialize_parameters_normal(const double& mean, const double& standard_deviation)
02041 {
02042 parameters.initialize_normal(mean, standard_deviation);
02043
02044 if(bounding_flag)
02045 {
02046 bound_parameters();
02047 }
02048 }
02049
02050
02051
02052
02057
02058 void IndependentParameters::initialize_parameters_normal(const Vector<double>& mean, const Vector<double>& standard_deviation)
02059 {
02060 parameters.initialize_normal(mean, standard_deviation);
02061
02062 if(bounding_flag)
02063 {
02064 bound_parameters();
02065 }
02066 }
02067
02068
02069
02070
02077
02078 void IndependentParameters::initialize_parameters_normal(const Vector< Vector<double> >& mean_standard_deviation)
02079 {
02080 parameters.initialize_normal(mean_standard_deviation[0], mean_standard_deviation[1]);
02081
02082 if(bounding_flag)
02083 {
02084 bound_parameters();
02085 }
02086 }
02087
02088
02089
02090
02093
02094 void IndependentParameters::initialize_random(void)
02095 {
02096 const unsigned int parameters_number = rand()%10 + 2;
02097
02098 set(parameters_number);
02099
02100 parameters.initialize_normal();
02101
02102 minimums.set(parameters_number);
02103 minimums.initialize_normal();
02104
02105 maximums.set(parameters_number);
02106 maximums.initialize_normal();
02107
02108 means.set(parameters_number);
02109 means.initialize_normal();
02110
02111 standard_deviations.set(parameters_number);
02112 standard_deviations.initialize_normal();
02113
02114 if(rand()%2)
02115 {
02116 set_scaling_method(MinimumMaximum);
02117
02118 }
02119 else
02120 {
02121 set_scaling_method(MeanStandardDeviation);
02122 }
02123
02124 if(rand()%2)
02125 {
02126 set_scaling_flag(false);
02127 }
02128 else
02129 {
02130 set_scaling_flag(true);
02131 }
02132
02133 lower_bounds.set(parameters_number);
02134 lower_bounds.initialize_uniform(-1.0, 0.0);
02135
02136 upper_bounds.set(parameters_number);
02137 upper_bounds.initialize_uniform(0.0, 1.0);
02138
02139 if(rand()%2)
02140 {
02141 set_bounding_flag(false);
02142 }
02143 else
02144 {
02145 set_bounding_flag(true);
02146 }
02147
02148 if(rand()%2)
02149 {
02150 set_display(false);
02151 }
02152 else
02153 {
02154 set_display(true);
02155 }
02156
02157 if(bounding_flag)
02158 {
02159 bound_parameters();
02160 }
02161 }
02162
02163
02164
02165
02168
02169 Vector<double> IndependentParameters::calculate_scaled_parameters(void) const
02170 {
02171 const unsigned int parameters_number = count_parameters_number();
02172
02173 switch(scaling_method)
02174 {
02175 case MinimumMaximum:
02176 {
02177 Vector<double> scaled_parameters(parameters_number);
02178
02179 for(unsigned int i = 0; i < parameters_number; i++)
02180 {
02181 if(maximums[i] - minimums[i] < 1.0e-99)
02182 {
02183 if(display)
02184 {
02185 std::cout << "OpenNN Warning: IndependentParameters class.\n"
02186 << "Vector<double> calculate_scaled_parameters(void) const method.\n"
02187 << "Maximum and minimum of parameter " << i << " are equal.\n"
02188 << "That parameter won't be scaled.\n";
02189 }
02190
02191 scaled_parameters[i] = parameters[i];
02192 }
02193 else
02194 {
02195 scaled_parameters[i] = 2.0*(parameters[i] - minimums[i])/(maximums[i] - minimums[i])-1.0;
02196 }
02197 }
02198
02199 return(scaled_parameters);
02200 }
02201 break;
02202
02203 case MeanStandardDeviation:
02204 {
02205 Vector<double> scaled_parameters(parameters_number);
02206
02207 for(unsigned int i = 0; i < parameters_number; i++)
02208 {
02209 if(standard_deviations[i] < 1.0e-99)
02210 {
02211 if(display)
02212 {
02213 std::cout << "OpenNN Warning: IndependentParameters class.\n"
02214 << "Vector<double> calculate_scaled_parameters(void) method.\n"
02215 << "Standard deviation of parameter " << i << " is zero.\n"
02216 << "That won't be unscaled.\n";
02217 }
02218
02219 scaled_parameters[i] = parameters[i];
02220 }
02221 else
02222 {
02223 scaled_parameters[i] = (parameters[i] - means[i])/standard_deviations[i];
02224 }
02225 }
02226
02227 return(scaled_parameters);
02228 }
02229 break;
02230
02231 default:
02232 {
02233 std::ostringstream buffer;
02234
02235 buffer << "OpenNN Exception: IndependentParameters class\n"
02236 << "Vector<double> calculate_scaled_parameters(void) method.\n"
02237 << "Unknown independent parameters scaling and unscaling method.\n";
02238
02239 throw std::logic_error(buffer.str());
02240 }
02241 break;
02242 }
02243 }
02244
02245
02246
02247
02250
02251 void IndependentParameters::unscale_parameters(const Vector<double>& scaled_parameters)
02252 {
02253 const unsigned int parameters_number = count_parameters_number();
02254
02255 switch(scaling_method)
02256 {
02257 case MeanStandardDeviation:
02258 {
02259 for(unsigned int i = 0; i < parameters_number; i++)
02260 {
02261 if(standard_deviations[i] < 1e-99)
02262 {
02263 if(display)
02264 {
02265 std::cout << "OpenNN Warning: IndependentParameters class\n"
02266 << "void unscale_parameters(void) method.\n"
02267 << "Standard deviation of parameter " << i << " is zero.\n"
02268 << "That parameter won't be scaled.\n";
02269 }
02270
02271 parameters[i] = scaled_parameters[i];
02272 }
02273 else
02274 {
02275 parameters[i] = means[i] + scaled_parameters[i]*standard_deviations[i];
02276 }
02277 }
02278 }
02279 break;
02280
02281 case MinimumMaximum:
02282 {
02283 for(unsigned int i = 0; i < parameters_number; i++)
02284 {
02285 if(maximums[i] - minimums[i] < 1e-99)
02286 {
02287 if(display)
02288 {
02289 std::cout << "OpenNN Warning: IndependentParameters class\n"
02290 << "void unscale_parameters(void) method.\n"
02291 << "Maximum and minimum of parameter " << i << " are equal.\n"
02292 << "That parameter won't be scaled.\n";
02293 }
02294
02295 parameters[i] = scaled_parameters[i];
02296 }
02297 else
02298 {
02299 parameters[i] = 0.5*(scaled_parameters[i] + 1.0)*(maximums[i]-minimums[i]) + minimums[i];
02300 }
02301 }
02302 }
02303 break;
02304
02305 default:
02306 {
02307 std::ostringstream buffer;
02308
02309 buffer << "OpenNN Exception: IndependentParameters class\n"
02310 << "void unscale_parameters(void) method.\n"
02311 << "Unknown scaling and unscaling method.\n";
02312
02313 throw std::logic_error(buffer.str());
02314 }
02315 break;
02316 }
02317
02318 if(bounding_flag)
02319 {
02320 bound_parameters();
02321 }
02322 }
02323
02324
02325
02326
02328
02329 void IndependentParameters::bound_parameters(void)
02330 {
02331 const unsigned int parameters_number = count_parameters_number();
02332
02333 const unsigned int lower_bounds_size = lower_bounds.size();
02334 const unsigned int upper_bounds_size = upper_bounds.size();
02335
02336 if(lower_bounds_size == parameters_number && upper_bounds_size == parameters_number)
02337 {
02338 parameters.apply_lower_upper_bounds(lower_bounds, upper_bounds);
02339 }
02340 else if(lower_bounds_size == parameters_number)
02341 {
02342 parameters.apply_lower_bound(lower_bounds);
02343 }
02344 else if(upper_bounds_size == parameters_number)
02345 {
02346 parameters.apply_upper_bound(upper_bounds);
02347 }
02348 }
02349
02350
02351
02352
02355
02356 void IndependentParameters::bound_parameter(const unsigned int& index)
02357 {
02358 if(lower_bounds != 0 && upper_bounds != 0)
02359 {
02360 if(parameters[index] < lower_bounds[index])
02361 {
02362 parameters[index] = lower_bounds[index];
02363 }
02364 else if(parameters[index] > upper_bounds[index])
02365 {
02366 parameters[index] = upper_bounds[index];
02367 }
02368 }
02369 else if(lower_bounds != 0)
02370 {
02371 if(parameters[index] < lower_bounds[index])
02372 {
02373 parameters[index] = lower_bounds[index];
02374 }
02375 }
02376 else if(upper_bounds != 0)
02377 {
02378 if(parameters[index] > upper_bounds[index])
02379 {
02380 parameters[index] = upper_bounds[index];
02381 }
02382 }
02383 }
02384
02385
02386
02387
02389
02390 std::string IndependentParameters::to_string(void) const
02391 {
02392 std::ostringstream buffer;
02393
02394 buffer << "Independent parameters\n"
02395 << "Parameters: " << parameters << "\n"
02396 << "Names: " << names << "\n"
02397 << "Units: " << units << "\n"
02398 << "Descriptions: " << descriptions << "\n"
02399 << "Minimums: " << minimums << "\n"
02400 << "Maximums: " << maximums << "\n"
02401 << "Means: " << means << "\n"
02402 << "Standard deviations: " << standard_deviations << "\n"
02403 << "Lower bounds: " << lower_bounds << "\n"
02404 << "Upper bounds: " << upper_bounds << "\n"
02405 << "Scaling method: " << scaling_method << "\n"
02406 << "Scaling flag: " << scaling_flag << "\n"
02407 << "Bounding flag: " << bounding_flag << "\n"
02408 << "Display range warning: " << display_range_warning << "\n"
02409 << "Display: " << display << "\n";
02410
02411 return(buffer.str());
02412 }
02413
02414
02415
02416
02419
02420 TiXmlElement* IndependentParameters::to_XML(void) const
02421 {
02422 std::ostringstream buffer;
02423
02424 TiXmlElement* independent_parameters_element = new TiXmlElement("IndependentParameters");
02425 independent_parameters_element->SetAttribute("Version", 4);
02426
02427 const unsigned int parameters_number = count_parameters_number();
02428
02429
02430
02431 TiXmlElement* parameters_element = new TiXmlElement("Parameters");
02432 independent_parameters_element->LinkEndChild(parameters_element);
02433
02434 buffer.str("");
02435 buffer << parameters;
02436
02437 TiXmlText* parameters_text = new TiXmlText(buffer.str().c_str());
02438 parameters_element->LinkEndChild(parameters_text);
02439
02440
02441 {
02442 TiXmlElement* names_element = new TiXmlElement("Names");
02443 independent_parameters_element->LinkEndChild(names_element);
02444
02445 Vector<TiXmlElement*> elements(parameters_number);
02446 Vector<TiXmlText*> texts(parameters_number);
02447
02448 for(unsigned int i = 0; i < parameters_number; i++)
02449 {
02450 elements[i] = new TiXmlElement("Name");
02451 elements[i]->SetAttribute("Index", i+1);
02452 names_element->LinkEndChild(elements[i]);
02453
02454 texts[i] = new TiXmlText(names[i].c_str());
02455 elements[i]->LinkEndChild(texts[i]);
02456 }
02457 }
02458
02459
02460
02461 {
02462 TiXmlElement* units_element = new TiXmlElement("Units");
02463 independent_parameters_element->LinkEndChild(units_element);
02464
02465 Vector<TiXmlElement*> elements(parameters_number);
02466 Vector<TiXmlText*> texts(parameters_number);
02467
02468 for(unsigned int i = 0; i < parameters_number; i++)
02469 {
02470 elements[i] = new TiXmlElement("Unit");
02471 elements[i]->SetAttribute("Index", i+1);
02472 units_element->LinkEndChild(elements[i]);
02473
02474 texts[i] = new TiXmlText(units[i].c_str());
02475 elements[i]->LinkEndChild(texts[i]);
02476 }
02477 }
02478
02479
02480 {
02481 TiXmlElement* descriptions_element = new TiXmlElement("Descriptions");
02482 independent_parameters_element->LinkEndChild(descriptions_element);
02483
02484 Vector<TiXmlElement*> elements(parameters_number);
02485 Vector<TiXmlText*> texts(parameters_number);
02486
02487 for(unsigned int i = 0; i < parameters_number; i++)
02488 {
02489 elements[i] = new TiXmlElement("Description");
02490 elements[i]->SetAttribute("Index", i+1);
02491 descriptions_element->LinkEndChild(elements[i]);
02492
02493 texts[i] = new TiXmlText(descriptions[i].c_str());
02494 elements[i]->LinkEndChild(texts[i]);
02495 }
02496 }
02497
02498
02499 {
02500 TiXmlElement* element = new TiXmlElement("Minimums");
02501 independent_parameters_element->LinkEndChild(element);
02502
02503 buffer.str("");
02504 buffer << minimums;
02505
02506 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02507 element->LinkEndChild(text);
02508 }
02509
02510
02511
02512 {
02513 TiXmlElement* element = new TiXmlElement("Maximums");
02514 independent_parameters_element->LinkEndChild(element);
02515
02516 buffer.str("");
02517 buffer << maximums;
02518
02519 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02520 element->LinkEndChild(text);
02521 }
02522
02523
02524 {
02525 TiXmlElement* element = new TiXmlElement("Means");
02526 independent_parameters_element->LinkEndChild(element);
02527
02528 buffer.str("");
02529 buffer << means;
02530
02531 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02532 element->LinkEndChild(text);
02533 }
02534
02535
02536
02537 {
02538 TiXmlElement* element = new TiXmlElement("StandardDeviations");
02539 independent_parameters_element->LinkEndChild(element);
02540
02541 buffer.str("");
02542 buffer << standard_deviations;
02543
02544 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02545 element->LinkEndChild(text);
02546 }
02547
02548
02549 {
02550 TiXmlElement* element = new TiXmlElement("LowerBounds");
02551 independent_parameters_element->LinkEndChild(element);
02552
02553 buffer.str("");
02554 buffer << lower_bounds;
02555
02556 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02557 element->LinkEndChild(text);
02558 }
02559
02560
02561 {
02562 TiXmlElement* element = new TiXmlElement("UpperBounds");
02563 independent_parameters_element->LinkEndChild(element);
02564
02565 buffer.str("");
02566 buffer << upper_bounds;
02567
02568 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02569 element->LinkEndChild(text);
02570 }
02571
02572
02573 {
02574 TiXmlElement* element = new TiXmlElement("ScalingMethod");
02575 independent_parameters_element->LinkEndChild(element);
02576
02577 TiXmlText* text = new TiXmlText(write_scaling_method().c_str());
02578 element->LinkEndChild(text);
02579 }
02580
02581
02582
02583 {
02584 TiXmlElement* element = new TiXmlElement("ScalingFlag");
02585 independent_parameters_element->LinkEndChild(element);
02586
02587 buffer.str("");
02588 buffer << scaling_flag;
02589
02590 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02591 element->LinkEndChild(text);
02592 }
02593
02594
02595
02596 {
02597 TiXmlElement* element = new TiXmlElement("BoundingFlag");
02598 independent_parameters_element->LinkEndChild(element);
02599
02600 buffer.str("");
02601 buffer << bounding_flag;
02602
02603 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02604 element->LinkEndChild(text);
02605 }
02606
02607
02608 {
02609 TiXmlElement* element = new TiXmlElement("DisplayRangeWarning");
02610 independent_parameters_element->LinkEndChild(element);
02611
02612 buffer.str("");
02613 buffer << display_range_warning;
02614
02615 TiXmlText* text = new TiXmlText(buffer.str().c_str());
02616 element->LinkEndChild(text);
02617 }
02618
02619
02620 {
02621 TiXmlElement* display_element = new TiXmlElement("Display");
02622 independent_parameters_element->LinkEndChild(display_element);
02623
02624 buffer.str("");
02625 buffer << display;
02626
02627 TiXmlText* display_text = new TiXmlText(buffer.str().c_str());
02628 display_element->LinkEndChild(display_text);
02629 }
02630
02631 return(independent_parameters_element);
02632 }
02633
02634
02635
02636
02639
02640 void IndependentParameters::from_XML(TiXmlElement* independent_parameters_element)
02641 {
02642 if(independent_parameters_element)
02643 {
02644 int index = 0;
02645
02646 unsigned int parameters_number = count_parameters_number();
02647
02648
02649 {
02650 TiXmlElement* parameters_element = independent_parameters_element->FirstChildElement("Parameters");
02651
02652 if(parameters_element)
02653 {
02654 }
02655
02656 set(parameters);
02657
02658 parameters_number = count_parameters_number();
02659 }
02660
02661
02662 {
02663 TiXmlElement* names_element = independent_parameters_element->FirstChildElement("Names");
02664
02665 if(names_element)
02666 {
02667 Vector<std::string> new_names(parameters_number);
02668
02669 TiXmlElement* name_element = names_element->FirstChildElement("Name");
02670
02671 if(name_element)
02672 {
02673 name_element->QueryIntAttribute("Index", &index);
02674
02675 if(name_element->GetText())
02676 {
02677 new_names[index-1] = name_element->GetText();
02678 }
02679
02680 for( ; name_element; name_element=name_element->NextSiblingElement())
02681 {
02682 name_element->QueryIntAttribute("Index", &index);
02683
02684 if(name_element->GetText())
02685 {
02686 new_names[index-1] = name_element->GetText();
02687 }
02688 }
02689 }
02690
02691 try
02692 {
02693 set_names(new_names);
02694 }
02695 catch(std::exception& e)
02696 {
02697 std::cout << e.what() << std::endl;
02698 }
02699 }
02700 }
02701
02702
02703 {
02704 TiXmlElement* units_element = independent_parameters_element->FirstChildElement("VariablesUnits");
02705
02706 if(units_element)
02707 {
02708 Vector<std::string> new_units(parameters_number);
02709
02710 TiXmlElement* variable_units_element = units_element->FirstChildElement("VariableUnits");
02711
02712 if(variable_units_element)
02713 {
02714 variable_units_element->QueryIntAttribute("Index", &index);
02715
02716 if(variable_units_element->GetText())
02717 {
02718 new_units[index-1] = variable_units_element->GetText();
02719 }
02720
02721 for( ; variable_units_element; variable_units_element=variable_units_element->NextSiblingElement())
02722 {
02723 variable_units_element->QueryIntAttribute("Index", &index);
02724
02725 if(variable_units_element->GetText())
02726 {
02727 new_units[index-1] = variable_units_element->GetText();
02728 }
02729 }
02730 }
02731
02732 try
02733 {
02734 set_units(new_units);
02735 }
02736 catch(std::exception& e)
02737 {
02738 std::cout << e.what() << std::endl;
02739 }
02740 }
02741 }
02742
02743
02744 {
02745 TiXmlElement* descriptions_element = independent_parameters_element->FirstChildElement("Descriptions");
02746
02747 if(descriptions_element)
02748 {
02749 Vector<std::string> new_descriptions(parameters_number);
02750
02751 TiXmlElement* variable_description_element = descriptions_element->FirstChildElement("Description");
02752
02753 if(variable_description_element)
02754 {
02755 variable_description_element->QueryIntAttribute("Index", &index);
02756
02757 if(variable_description_element->GetText())
02758 {
02759 new_descriptions[index-1] = variable_description_element->GetText();
02760 }
02761
02762 for( ; variable_description_element; variable_description_element=variable_description_element->NextSiblingElement())
02763 {
02764 variable_description_element->QueryIntAttribute("Index", &index);
02765
02766 if(variable_description_element->GetText())
02767 {
02768 new_descriptions[index-1] = variable_description_element->GetText();
02769 }
02770 }
02771 }
02772
02773 try
02774 {
02775 set_descriptions(new_descriptions);
02776 }
02777 catch(std::exception& e)
02778 {
02779 std::cout << e.what() << std::endl;
02780 }
02781 }
02782 }
02783
02784
02785 {
02786 TiXmlElement* minimums_element = independent_parameters_element->FirstChildElement("Minimums");
02787
02788 if(minimums_element)
02789 {
02790 const char* minimums_text = minimums_element->GetText();
02791
02792 if(minimums_text)
02793 {
02794 Vector<double> new_minimums;
02795 new_minimums.parse(minimums_text);
02796
02797 try
02798 {
02799 set_minimums(new_minimums);
02800 }
02801 catch(std::exception& e)
02802 {
02803 std::cout << e.what() << std::endl;
02804 }
02805 }
02806 }
02807 }
02808
02809
02810 {
02811 TiXmlElement* maximums_element = independent_parameters_element->FirstChildElement("Maximums");
02812
02813 if(maximums_element)
02814 {
02815 const char* maximums_text = maximums_element->GetText();
02816
02817 if(maximums_text)
02818 {
02819 Vector<double> new_maximums;
02820 new_maximums.parse(maximums_text);
02821
02822 try
02823 {
02824 set_maximums(new_maximums);
02825 }
02826 catch(std::exception& e)
02827 {
02828 std::cout << e.what() << std::endl;
02829 }
02830 }
02831 }
02832 }
02833
02834
02835 {
02836 TiXmlElement* means_element = independent_parameters_element->FirstChildElement("Means");
02837
02838 if(means_element)
02839 {
02840 const char* means_text = means_element->GetText();
02841
02842 if(means_text)
02843 {
02844 Vector<double> new_means;
02845 new_means.parse(means_text);
02846
02847 try
02848 {
02849 set_means(new_means);
02850 }
02851 catch(std::exception& e)
02852 {
02853 std::cout << e.what() << std::endl;
02854 }
02855 }
02856 }
02857 }
02858
02859
02860 {
02861 TiXmlElement* standard_deviations_element = independent_parameters_element->FirstChildElement("StandardDeviations");
02862
02863 if(standard_deviations_element)
02864 {
02865 const char* standard_deviations_text = standard_deviations_element->GetText();
02866
02867 if(standard_deviations_text)
02868 {
02869 Vector<double> new_standard_deviations;
02870 new_standard_deviations.parse(standard_deviations_text);
02871
02872 try
02873 {
02874 set_standard_deviations(new_standard_deviations);
02875 }
02876 catch(std::exception& e)
02877 {
02878 std::cout << e.what() << std::endl;
02879 }
02880 }
02881 }
02882 }
02883
02884
02885 {
02886 TiXmlElement* lower_bounds_element = independent_parameters_element->FirstChildElement("LowerBounds");
02887
02888 if(lower_bounds_element)
02889 {
02890 const char* lower_bounds_text = lower_bounds_element->GetText();
02891
02892 if(lower_bounds_text)
02893 {
02894 Vector<double> new_lower_bounds;
02895 new_lower_bounds.parse(lower_bounds_text);
02896
02897 try
02898 {
02899 set_lower_bounds(new_lower_bounds);
02900 }
02901 catch(std::exception& e)
02902 {
02903 std::cout << e.what() << std::endl;
02904 }
02905 }
02906 }
02907 }
02908
02909
02910 {
02911 TiXmlElement* upper_bounds_element = independent_parameters_element->FirstChildElement("UpperBounds");
02912
02913 if(upper_bounds_element)
02914 {
02915 const char* upper_bounds_text = upper_bounds_element->GetText();
02916
02917 if(upper_bounds_text)
02918 {
02919 Vector<double> new_upper_bounds;
02920 new_upper_bounds.parse(upper_bounds_text);
02921
02922 try
02923 {
02924 set_upper_bounds(new_upper_bounds);
02925 }
02926 catch(std::exception& e)
02927 {
02928 std::cout << e.what() << std::endl;
02929 }
02930 }
02931 }
02932 }
02933
02934
02935 {
02936 TiXmlElement* display_element = independent_parameters_element->FirstChildElement("Display");
02937
02938 if(display)
02939 {
02940 std::string new_display_string = display_element->GetText();
02941
02942 try
02943 {
02944 set_display(new_display_string != "0");
02945 }
02946 catch(std::exception& e)
02947 {
02948 std::cout << e.what() << std::endl;
02949 }
02950 }
02951 }
02952 }
02953 }
02954
02955 }
02956
02957
02958
02959
02960
02961
02962
02963
02964
02965
02966
02967
02968
02969
02970
02971
02972