Clean code

opennn/batch.cpp

@@ -80,7 +80,7 @@ void Batch::perform_augmentation() const
 
         if(random_rotation_minimum != 0 && random_rotation_maximum != 0)
         {
-            const type angle = (random_rotation_minimum < random_rotation_maximum)
+            const type angle = random_rotation_minimum < random_rotation_maximum
                              ? random_rotation_minimum + type(rand())
                              : random_rotation_maximum;
 
@@ -89,7 +89,7 @@ void Batch::perform_augmentation() const
 
         if(random_rescaling_minimum != 0 && random_rescaling_maximum != 0)
         {
-            const type rescaling = (random_rescaling_minimum < random_rescaling_maximum)
+            const type rescaling = random_rescaling_minimum < random_rescaling_maximum
                                  ? random_rescaling_minimum + type(rand())
                                  : random_rescaling_maximum;
 
@@ -98,7 +98,7 @@ void Batch::perform_augmentation() const
 
         if(random_horizontal_translation_minimum != 0 && random_horizontal_translation_maximum != 0)
         {
-            const type translation = (random_horizontal_translation_minimum < random_rescaling_maximum)
+            const type translation = random_horizontal_translation_minimum < random_rescaling_maximum
                                    ? random_horizontal_translation_minimum + type(rand())
                                    : random_rescaling_maximum;
 

opennn/bounding_layer.cpp

@@ -515,7 +515,7 @@ void BoundingLayer::write_XML(tinyxml2::XMLPrinter& file_stream) const
     {
         file_stream.OpenElement("Item");
 
-        file_stream.PushAttribute("Index", static_cast<unsigned>(i+1));
+        file_stream.PushAttribute("Index", unsigned(i+1));
 
         // Lower bound
 

opennn/config.h

@@ -45,20 +45,20 @@
 
 namespace opennn
 {
-    //using namespace std;
+    using namespace std;
     using namespace Eigen;
 
     using type = float; 
 
-    using dimensions = std::vector<Index>;
+    using dimensions = vector<Index>;
 
     //using execution_policy = std::execution::par;
 
     template<typename Base, typename T>
-    inline bool is_instance_of(const T* ptr) {
+    inline bool is_instance_of(const T* ptr)
+    {
         return dynamic_cast<const Base*>(ptr) != nullptr;
     }
-
 }
 
 

opennn/convolutional_layer.cpp

@@ -466,8 +466,8 @@ void ConvolutionalLayer::back_propagate(const Tensor<pair<type*, dimensions>, 1>
 
     Tensor<type, 1>& biases_derivatives = convolutional_layer_back_propagation->biases_derivatives;
 
-    Eigen::array<Eigen::Index, 4> offsets;
-    Eigen::array<Eigen::Index, 4> extents;
+    Eigen::array<Index, 4> offsets;
+    Eigen::array<Index, 4> extents;
 
     // Synaptic weights derivatives
 

opennn/correlations.cpp

@@ -466,7 +466,7 @@ pair<Tensor<type, 2>, Tensor<type, 2>> filter_missing_values_matrix_matrix(const
 Tensor<type, 2> get_correlation_values(const Tensor<Correlation, 2>& correlations)
 {
     Tensor<type, 2> values;
-    /**
+    /*
     const Index rows_number = correlations.dimension(0);
     const Index raw_variables_number = correlations.dimension(1);
     Tensor<type, 2> values(rows_number, raw_variables_number);
@@ -922,7 +922,7 @@ Correlation logistic_correlation_vector_vector_spearman(const ThreadPoolDevice*
     correlation.r = linear_correlation(thread_pool_device, outputs.reshape(vector), targets.reshape(vector)).r;
 
     const type z_correlation = r_correlation_to_z_correlation(correlation.r);
-/**
+/*
     const Tensor<type, 1> confidence_interval_z = confidence_interval_z_correlation(z_correlation, inputs_dimensions(0));
 
     correlation.lower_confidence = z_correlation_to_r_correlation(confidence_interval_z(0));

opennn/cross_entropy_error.cpp

@@ -167,9 +167,6 @@ void CrossEntropyError::calculate_binary_output_delta(const Batch& batch,
     const ProbabilisticLayerForwardPropagation* probabilistic_layer_forward_propagation
             = static_cast<ProbabilisticLayerForwardPropagation*>(forward_propagation.layers(last_trainable_layer_index));
 
-    ProbabilisticLayerBackPropagation* probabilistic_layer_back_propagation
-            = static_cast<ProbabilisticLayerBackPropagation*>(back_propagation.neural_network.layers(last_trainable_layer_index));
-
     const Tensor<type, 2>& outputs = probabilistic_layer_forward_propagation->outputs;
 
     // Back propagation
@@ -189,9 +186,6 @@ void CrossEntropyError::calculate_multiple_output_delta(const Batch& batch,
 {
     const Index last_trainable_layer_index = neural_network->get_last_trainable_layer_index();
 
-    ProbabilisticLayerBackPropagation* probabilistic_layer_back_propagation
-            = static_cast<ProbabilisticLayerBackPropagation*>(back_propagation.neural_network.layers(last_trainable_layer_index));
-
     const Index batch_samples_number = batch.get_batch_samples_number();
 
     const pair<type*, dimensions> targets_pair = batch.get_targets_pair();

opennn/data_set.cpp

@@ -68,15 +68,15 @@ DataSet::DataSet(const Tensor<type, 2>& data, const Index& samples_number, const
 
 void DataSet::set_default_columns_scalers()
 {
-    const Index columns_number = raw_variables.size();
+    const Index raw_variables_number = raw_variables.size();
 
     if (model_type == ModelType::ImageClassification)
     {
         set_raw_variables_scalers(Scaler::MinimumMaximum);
     }
     else
     {
-        for (Index i = 0; i < columns_number; i++)
+        for (Index i = 0; i < raw_variables_number; i++)
         {
             if (raw_variables(i).type == RawVariableType::Numeric)
             {
@@ -6343,7 +6343,7 @@ Tensor<Correlation, 2> DataSet::calculate_input_target_raw_variables_correlation
             cout << "input_raw_variable_data: " << input_raw_variable_data << endl;
             cout << "target_raw_variable_data: " << target_raw_variable_data << endl;
 
-            correlations(i,j) = opennn::correlation(correlations_thread_pool_device, input_raw_variable_data, target_raw_variable_data);
+            correlations(i,j) = correlation(correlations_thread_pool_device, input_raw_variable_data, target_raw_variable_data);
         }
     }
 
@@ -6366,8 +6366,7 @@ Tensor<Correlation, 2> DataSet::calculate_relevant_input_target_raw_variables_co
 
     Tensor<Correlation, 2> correlations(input_raw_variables_number, target_raw_variables_number);
 
-
-#pragma omp parallel for
+    #pragma omp parallel for
     for(Index i = 0; i < input_raw_variables_number; i++)
     {
         const Index input_index = input_raw_variables_indices(i);
@@ -6379,17 +6378,17 @@ Tensor<Correlation, 2> DataSet::calculate_relevant_input_target_raw_variables_co
             const Tensor<type, 2> input_raw_variable_data = get_raw_variable_data(input_index, get_used_samples_indices());
             const Tensor<type, 2> target_raw_variable_data = get_raw_variable_data(target_index, get_used_samples_indices());
 
-            correlations(i, j) = opennn::correlation(correlations_thread_pool_device, input_raw_variable_data, target_raw_variable_data);
+            correlations(i, j) = correlation(correlations_thread_pool_device, input_raw_variable_data, target_raw_variable_data);
         }
     }
+
     delete correlations_thread_pool;
     delete correlations_thread_pool_device;
+
     return correlations;
 }
 
 
-
-
 Tensor<Correlation, 2> DataSet::calculate_input_target_raw_variables_correlations_spearman() const
 {
     const Index input_raw_variables_number = get_input_raw_variables_number();
@@ -6414,7 +6413,7 @@ Tensor<Correlation, 2> DataSet::calculate_input_target_raw_variables_correlation
 
             const Tensor<type, 2> target_raw_variable_data = get_raw_variable_data(target_index, used_samples_indices);
 
-            correlations(i,j) = opennn::correlation_spearman(thread_pool_device, input_raw_variable_data, target_raw_variable_data);
+            correlations(i,j) = correlation_spearman(thread_pool_device, input_raw_variable_data, target_raw_variable_data);
         }
     }
 
@@ -6596,27 +6595,17 @@ Tensor<Tensor<Correlation, 2>, 1> DataSet::calculate_input_raw_variables_correla
 
                 if(calculate_pearson_correlations)
                 {
-                    correlations(i,j) = opennn::correlation(thread_pool_device, input_i, input_j);
-
-                    cout << "-=-=-=-=-=-" << endl;
-                    cout << " i : " << i  << "&&" << " j : " << j << endl;
-                    cout << "-=-=-=-=-=-" << endl;
-                    cout << "input_i :: " << input_i << endl;
-                    cout << "input_j :: " << input_j << endl;
-                    cout << "correlations(i,j).r :: " << correlations(i,j).r << endl;
-                    cout << "type(1) :: " << type(1) << endl;
-                    cout << "NUMERIC_LIMITS_MIN :: " << NUMERIC_LIMITS_MIN << endl;
-                    cout << "-=-=-=-=-=-" << endl;
-
-                    if(correlations(i,j).r > (type(1) - NUMERIC_LIMITS_MIN))
+                    correlations(i,j) = correlation(thread_pool_device, input_i, input_j);
+
+                    if(correlations(i,j).r > type(1) - NUMERIC_LIMITS_MIN)
                        correlations(i,j).r =  type(1);
                 }
 
                 if(calculate_spearman_correlations)
                 {
-                    correlations_spearman(i,j) = opennn::correlation_spearman(thread_pool_device, input_i, input_j);
+                    correlations_spearman(i,j) = correlation_spearman(thread_pool_device, input_i, input_j);
 
-                    if(correlations_spearman(i,j).r > (type(1) - NUMERIC_LIMITS_MIN))
+                    if(correlations_spearman(i,j).r > type(1) - NUMERIC_LIMITS_MIN)
                         correlations_spearman(i,j).r = type(1);
                 }
             }
@@ -7799,7 +7788,7 @@ void DataSet::from_XML(const tinyxml2::XMLDocument& data_set_document)
         }
     }
 
-    /**
+    /*
 //    // Time series raw_variables
 
 //    const tinyxml2::XMLElement* time_series_raw_variables_element = data_set_element->FirstChildElement("TimeSeriesraw_variables");
@@ -8461,7 +8450,7 @@ void DataSet::save_data() const
         ostringstream buffer;
 
         buffer << "OpenNN Exception: Matrix template." << endl
-               << "void save_csv(const string&, const char&, const Vector<string>&, const Vector<string>&) method." << endl
+               << "void save_data() method." << endl
                << "Cannot open matrix data file: " << data_source_path << endl;
 
         throw runtime_error(buffer.str());
@@ -9605,8 +9594,8 @@ void DataSet::read_csv_1()
 
     if(has_raw_variables_names)
     {
-        has_rows_labels ? set_raw_variables_names(data_file_preview(0).slice(Eigen::array<Eigen::Index, 1>({1}),
-                                                                       Eigen::array<Eigen::Index, 1>({data_file_preview(0).size()-1})))
+        has_rows_labels ? set_raw_variables_names(data_file_preview(0).slice(Eigen::array<Index, 1>({1}),
+                                                                       Eigen::array<Index, 1>({data_file_preview(0).size()-1})))
                         : set_raw_variables_names(data_file_preview(0));
     }
     else
@@ -9857,16 +9846,20 @@ void DataSet::read_csv_2_simple()
 void DataSet::read_csv_3_simple()
 {
     const regex accent_regex("[\\xC0-\\xFF]");
+
     ifstream file;
 
     #ifdef _WIN32
 
     if(std::regex_search(data_source_path, accent_regex))
     {
         wstring_convert<std::codecvt_utf8<wchar_t>> conv;
+
         wstring file_name_wide = conv.from_bytes(data_source_path);
+
         file.open(file_name_wide);
-    }else
+    }
+    else
     {
         file.open(data_source_path.c_str());
     }
@@ -9964,8 +9957,6 @@ void DataSet::read_csv_3_simple()
 
         raw_variable_index = 0;
         sample_index++;
-
-        type percentage = static_cast<type>(sample_index)/static_cast<type>(samples_number);
     }
 
     const Index data_file_preview_index = has_raw_variables_names ? 3 : 2;
@@ -10080,7 +10071,7 @@ void DataSet::read_csv_2_complete()
 
         tokens_count = tokens.size();
 
-        if(static_cast<unsigned>(tokens_count) != raw_raw_variables_number)
+        if(unsigned(tokens_count) != raw_raw_variables_number)
         {
             const string message =
                     "Sample " + to_string(lines_count+1) + " error:\n"
@@ -10131,7 +10122,7 @@ void DataSet::read_csv_2_complete()
 
     file.close();
 
-    const Index samples_number = static_cast<unsigned>(lines_count);
+    const Index samples_number = unsigned(lines_count);
 
     const Index variables_number = get_variables_number();
 
@@ -10401,8 +10392,6 @@ void DataSet::read_csv_3_complete()
         }
 
         sample_index++;
-
-        type percentage = static_cast<type>(sample_index)/static_cast<type>(data.dimension(0));
     }
 
     const Index data_file_preview_index = has_raw_variables_names ? 3 : 2;

opennn/embedding_layer.cpp

@@ -248,7 +248,7 @@ void EmbeddingLayer::set_parameters_random()
     {
         for(Index j = 0; j < embedding_weights.dimension(1); j++)
         {
-            const type random = static_cast<type>(rand()/(RAND_MAX+1.0));
+            const type random = type(rand()/(RAND_MAX+1.0));
 
             embedding_weights(i, j) = minimum + (maximum - minimum)*random;
         }
@@ -376,10 +376,6 @@ void EmbeddingLayer::back_propagate(const Tensor<pair<type*, dimensions>, 1>& in
 
     const TensorMap<Tensor<type, 3>> deltas(deltas_pair(0).first, batch_samples_number, inputs_number, deltas_pair(0).second[2]);
 
-    // Forward propagation
-
-    EmbeddingLayerForwardPropagation* embedding_layer_forward_propagation = static_cast<EmbeddingLayerForwardPropagation*>(forward_propagation);
-
     // Back propagation
 
     EmbeddingLayerBackPropagation* embedding_layer_back_propagation = static_cast<EmbeddingLayerBackPropagation*>(back_propagation);

opennn/flatten_layer.cpp

@@ -258,11 +258,11 @@ void FlattenLayer::from_XML(const tinyxml2::XMLDocument& document)
 
     const Index input_channels_number = Index(atoi(input_channels_number_element->GetText()));
 
-//    Tensor<Index,1> inputsDimensionTensor(4);
+    Tensor<Index,1> inputsDimensionTensor(4);
 
-//    inputsDimensionTensor.setValues({input_height, input_width, input_channels_number, 0});
+    inputsDimensionTensor.setValues({input_height, input_width, input_channels_number, 0});
 
-//    set(inputsDimensionTensor);
+    //set(inputsDimensionTensor);
 
     // @todo Change to dimensions
     /*

opennn/genetic_algorithm.cpp

@@ -523,7 +523,7 @@ void GeneticAlgorithm::initialize_population_random()
 
     cout << "Creating initial random population" << endl;
 
-    srand(static_cast<unsigned>(time(nullptr)));
+    srand(unsigned(time(nullptr)));
 
     for(Index i = 0; i < individuals_number; i++)
     {

opennn/images.cpp

@@ -74,8 +74,8 @@ Tensor<unsigned char, 3> read_bmp_image(const string& filename)
 
         const Tensor<unsigned char, 1> data_without_padding = remove_padding(image_data, rows_number, columns_number, padding);
 
-        const Eigen::array<Eigen::Index, 3> dims_3D = {channels, rows_number, columns_number};
-        const Eigen::array<Eigen::Index, 1> dims_1D = {rows_number*columns_number};
+        const Eigen::array<Index, 3> dims_3D = {channels, rows_number, columns_number};
+        const Eigen::array<Index, 1> dims_1D = {rows_number*columns_number};
 
         Tensor<unsigned char,1> red_channel_flatted = data_without_padding.reshape(dims_3D).chip(2,0).reshape(dims_1D); // row_major
         Tensor<unsigned char,1> green_channel_flatted = data_without_padding.reshape(dims_3D).chip(1,0).reshape(dims_1D); // row_major
@@ -124,17 +124,17 @@ ImageData read_bmp_image_gpt(const std::string& filename)
     char header[54];
     file.read(header, 54);
 
-    int width = *(int*)&header[18];
-    int height = *(int*)&header[22];
-    int channels = header[28] == 24 ? 3 : 1;
+    const int width = *(int*)&header[18];
+    const int height = *(int*)&header[22];
+    const int channels = header[28] == 24 ? 3 : 1;
     int padding = 0;
 
     while ((channels * width + padding) % 4 != 0)
     {
         padding++;
     }
 
-    size_t size = height * (channels * width + padding);
+    const size_t size = height * (channels * width + padding);
     Tensor<unsigned char, 1> image_data(size);
 
     file.seekg(54, ios::beg);
@@ -148,8 +148,8 @@ ImageData read_bmp_image_gpt(const std::string& filename)
 
         const Tensor<unsigned char, 1> data_without_padding = remove_padding(image_data, rows_number, columns_number, padding);
 
-        const Eigen::array<Eigen::Index, 3> dims_3D = {channels, rows_number, columns_number};
-        const Eigen::array<Eigen::Index, 1> dims_1D = {rows_number*columns_number};
+        const Eigen::array<Index, 3> dims_3D = {channels, rows_number, columns_number};
+        const Eigen::array<Index, 1> dims_1D = {rows_number*columns_number};
 
         Tensor<unsigned char,1> red_channel_flatted = data_without_padding.reshape(dims_3D).chip(2,0).reshape(dims_1D);
         Tensor<unsigned char,1> green_channel_flatted = data_without_padding.reshape(dims_3D).chip(1,0).reshape(dims_1D);
@@ -440,7 +440,7 @@ Tensor<unsigned char, 1> resize_image(Tensor<unsigned char, 1> &data,
 
 //    memcpy(data.data(), image_data.data(), images_number * image_size * sizeof(type));
 
-    copy(/*execution::par,
+    copy(execution::par,
     image_data.data(), image_data.data() + images_number * image_size, data.data());
 
     rows_labels.resize(images_number);