output.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <string>
#include <functional>
#include <sstream>
#include <iterator>
#include <cmath>

#include <valarray>

using namespace std;

// Utility functions for array operations
template<typename T>
vector<T> flatten(const vector<vector<T>>& v) {
    vector<T> result;
    for (const auto& inner : v) {
        result.insert(result.end(), inner.begin(), inner.end());
    }
    return result;
}

template<typename T>
string serialize(const vector<T>& v) {
    ostringstream oss;
    copy(v.begin(), v.end(), ostream_iterator<T>(oss, ","));
    string result = oss.str();
    if (!result.empty()) result.pop_back();
    return result;
}

template<typename T>
vector<T> deserialize(const string& s) {
    vector<T> result;
    stringstream ss(s);
    string item;
    while (getline(ss, item, ',')) {
        stringstream itemss(item);
        T value;
        itemss >> value;
        result.push_back(value);
    }
    return result;
}

// Array operation functions
double square(double x) { return x * x; }
double add(double x, double y) { return x + y; }

// Broadcasting operations
template<typename T>
vector<vector<T>> operator+(const vector<T>& v1, const vector<vector<T>>& v2) {
    vector<vector<T>> result = v2;
    for (size_t i = 0; i < v2.size(); ++i) {
        for (size_t j = 0; j < v2[i].size(); ++j) {
            result[i][j] = v1[i] + v2[i][j];
        }
    }
    return result;
}

// Array copy and clone functions

template <typename T>
void deepCopyArray(std::vector<T>& dest, const std::vector<T>& src) {
    dest = src;
}

template <typename T>
void deepCopyArray(std::vector<std::vector<T>>& dest, const std::vector<std::vector<T>>& src) {
    dest.resize(src.size());
    for (size_t i = 0; i < src.size(); ++i) {
        deepCopyArray(dest[i], src[i]);
    }
}
template<typename T>
vector<T> clone_structure(const vector<T>& src) {
    return vector<T>(src.size());
}

template<typename T>
vector<vector<T>> clone_structure(const vector<vector<T>>& src) {
    vector<vector<T>> result;
    result.resize(src.size());
    for (size_t i = 0; i < src.size(); ++i) {
        result[i].resize(src[i].size());
    }
    return result;
}

// Type trait to check if a type has size() method
template<typename T>
struct has_size {
    template<typename U>
    static constexpr auto check(U*)
        -> decltype(std::declval<U>().size(), std::true_type());
    
    template<typename>
    static constexpr std::false_type check(...);
    
    static constexpr bool value = decltype(check<T>(nullptr))::value;
};

// Function to calculate dimensions recursively
template<typename T>
void calculateDimensions(const T& array, std::vector<size_t>& dimensions) {
    dimensions.push_back(array.size());
    
    if (!array.empty()) {
        if constexpr (has_size<typename T::value_type>::value) {
            calculateDimensions(array[0], dimensions);
        }
    }
}

// Function to get all dimensions of an array
template<typename T>
std::vector<size_t> getDimensions(const T& array) {
    std::vector<size_t> dimensions;
    calculateDimensions(array, dimensions);
    return dimensions;
}

// Function to get size of specific dimension
template<typename T>
size_t getDimensionSize(const T& array, size_t dimensionIndex) {
    auto dimensions = getDimensions(array);
    if (dimensionIndex >= dimensions.size()) {
        throw std::out_of_range("Dimension index out of range");
    }
    return dimensions[dimensionIndex];
}

        // Base case for non-vector types (innermost dimension)
template <typename T>
void resizeVector(T&, const std::vector<int>&, int) {
    // Do nothing for non-vector types
}

template <typename T>
void resizeVector(std::vector<T>& vec, const std::vector<int>& dimensions, int level = 0) {
    if (level == dimensions.size()) {
        return; // Base case: Stop recursion
    }
    vec.resize(dimensions[level]); // Resize the current level
    for (auto& subVec : vec) {
        resizeVector(subVec, dimensions, level + 1);
    }
}


int main() {
std::cout << "Hello World" << std::endl;
std::cout << 3.14 << std::endl;
vector<double> arr1(5);
vector<vector<double>> arr2(5, vector<double>(3, 0));
vector<vector<vector<double>>> arr3(5, vector<vector<double>>(3, vector<double>(4, 0)));
vector<vector<vector<vector<double>>>> arr4(4, vector<vector<vector<double>>>(1, vector<vector<double>>(3, vector<double>(4, 4.4))));
std::vector<double> arr5 = {1.000000000000, 2.400000000000, 3.140000000000, 22.400000000000, 21.200000000000};
std::vector<std::vector<double>> arr6 = {{1.000000000000, 2.000000000000}, {3.100000000000, 4.000000000000}, {3.140000000000, 7.220000000000}};
std::cout << arr2[2][2] << std::endl;
double hello = 3.14;
double hello2 = arr4[0][0][2][0];
// code for resizing arrays
resizeVector(arr2, {4, 2});
std::cout << "-----------Length------------" << std::endl;
int first_dim = getDimensionSize(arr3, 0);
int second_dim = getDimensionSize(arr3, 1);
int third_dim = getDimensionSize(arr3, 2);
std::cout << first_dim << std::endl;
std::cout << second_dim << std::endl;
std::cout << third_dim << std::endl;
std::cout << "-----------Length------------" << std::endl;
double total;
total = accumulate(begin(arr5), end(arr5), 0.0);
std::cout << "-------total-----" << std::endl;
std::cout << total << std::endl;
double highest;
highest = *max_element(begin(arr5), end(arr5));
double lowest;
lowest = *min_element(begin(arr5), end(arr5));
std::cout << "-------highest" << std::endl;
std::cout << highest << std::endl;
std::cout << "-------lowest-----" << std::endl;
std::cout << lowest << std::endl;
std::vector<double> flat;
for (const auto& row : arr6) {
    flat.insert(flat.end(), row.begin(), row.end());
}
std::cout << "-------flatten-----" << std::endl;
std::cout << flat[5] << std::endl;
std::valarray<double> squared(flat.size());
for(size_t i = 0; i < flat.size(); ++i) {
    squared[i] = flat[i] * flat[i];
}
double sumOfArray = 0.0;
double result = std::accumulate(flat.begin(), flat.end(), 0.0); // Calculate the sum
std::cout << "-------map-----" << std::endl;
std::cout << squared[4] << std::endl;
std::cout << "-------reduce-----" << std::endl;
std::cout << result << std::endl;
vector<double> arr7(5, 0);
{
    double range_start = static_cast<double>(1.1);
    double range_end = static_cast<double>(5.5);
    double step = (range_end - range_start) / (5 - 1);
    for (int i = 0; i < 5; ++i) {
        arr7[i] = range_start + i * step;
    }
}
std::cout << "-------range Based-----" << std::endl;
std::cout << arr7[2] << std::endl;
std::vector<std::vector<double>> resulted(arr6);
std::cout << "-------Copy-----" << std::endl;
std::cout << resulted[1][0] << std::endl;
std::vector<double> cloned(5);
cloned = arr5;
std::cout << "-------Clone-----" << std::endl;
std::cout << cloned[1] << std::endl;

    int original_size = arr5.size();
    std::vector<std::vector<double>> reshaped_arr;
    resizeVector(reshaped_arr, {2, 3});
    int idx = 0;
    for (int i = 0; i < 2; ++i) {
        for (int j = 0; j < 3; ++j) {
            if (idx < original_size) {
                reshaped_arr[i][j] = arr5[idx++];
            } else {
                reshaped_arr[i][j] = 0.0;
            }
        }
    }

std::cout << "-------Reshaped-----" << std::endl;
std::cout << reshaped_arr[0][2] << std::endl;
std::stringstream serial_ss;
serial_ss << arr5.size() << " ";
for(size_t i = 0; i < arr5.size(); ++i) {
    serial_ss << arr5[i] << " ";
}
std::string serial = serial_ss.str();
std::cout << "-------serialized-----" << std::endl;
std::cout << serial << std::endl;
std::stringstream new_arr2_ss(serial);
size_t new_arr2_size;
new_arr2_ss >> new_arr2_size;
std::valarray<double> new_arr2(new_arr2_size);
for(size_t i = 0; i < new_arr2_size; ++i) {
    new_arr2_ss >> new_arr2[i];
}
std::cout << "-------deserialized-----" << std::endl;
std::cout << new_arr2[1] << std::endl;
std::vector<double> array1d = {10.000000000000, 20.000000000000};
std::vector<std::vector<double>> array2d = {{1.000000000000, 2.000000000000, 3.000000000000}, {4.000000000000, 5.000000000000, 6.000000000000}};
vector<vector<double>> result2(2, vector<double>(3, 0));
result2 = array1d + array2d;
std::cout << "-------broadcast-----" << std::endl;
std::cout << result2[0][1] << std::endl;
double token = arr6[0][0];
double token2;
std::cout << "-------variable assign-----" << std::endl;
std::cout << token << std::endl;
arr6[0][0] = 11.1 + 12.2;
std::cout << "-------assignment-----" << std::endl;
std::cout << arr6[0][0] << std::endl;
std::vector<std::vector<double>> arr13 = {{1.000000000000, 2.000000000000, 3.000000000000, 4.000000000000}, {5.000000000000, 6.000000000000, 7.000000000000, 8.000000000000}, {9.000000000000, 10.000000000000, 11.000000000000, 12.000000000000}};
std::vector<double> arr13arr13;
for (const auto& row : arr13) {
    arr13arr13.insert(arr13arr13.end(), row.begin(), row.end());
}
std::valarray<double> arr13_arr13(arr13arr13.data(), arr13arr13.size());
std::slice row_slice_slice(8, 4, 1);
std::slice_array<double> row_slice_row_slice =  arr13_arr13[row_slice_slice];
std::valarray<double> row_slice(row_slice_row_slice);
std::cout << row_slice[1] << std::endl;
std::valarray<double> arr5_valarray(arr5.data(), arr5.size());
std::slice sliced_slice(1, 3, 1);
std::slice_array<double> sliced_sub_slice = arr5_valarray[sliced_slice];
std::valarray<double> sliced(sliced_sub_slice);
std::cout << sliced[0] << std::endl;
std::cout << sliced[1] << std::endl;
std::cout << sliced[2] << std::endl;
    return 0;
}