main.cpp

#include <iostream>
#include <vector>
#include "funcs.h"
#include "classes.h"
#include <cstdlib>
#include <cmath>

int main()
{
    std::vector<std::vector<double>> inputs;
    std::vector<std::vector<double>> targets;
    std::vector<int> numPerHidden;
    std::vector<double> res;

//---------------------------------------------------------
//-------------Sine wave approximation training------------
//---------------------------------------------------------

    /* int samples = 1000;

    for (int i = 0; i < samples; ++i)
    {
        double angle = (2 * M_PI * i) / samples;
        double normalized_angle = angle / (2 * M_PI);

        inputs.push_back({normalized_angle});

        double sine = std::sin(angle);
        double normalized_sine = (sine + 1.0) / 2.0;

        targets.push_back({normalized_sine});
    }

    std::vector<int> numPerHidden = {16, 16};
    Network N(1, 1, 2, numPerHidden);
    N.load("models/sinewave.txt");
    N.train(10000, inputs, targets, false);
    N.save("models/sinewave.txt"); */

    numPerHidden = {16, 16};
    Network sine(1, 1, 2, numPerHidden);
    sine.load("models/sinewave.txt");
    res = sine.predict({normalizeDeg(60)});
    std::cout << (res[0] * 2) - 1 << "\n";
 
//--------------------------------------------------------------------
//-----------------4-bit addition training----------------------------
//--------------------------------------------------------------------
    
 /* for (int a = 0; a < 16; ++a)
    {
        for (int b = 0; b < 16; ++b)
        {
            std::vector<double> input;
            for (int i = 3; i >= 0; --i)
                input.push_back((a >> i) & 1);

            for (int i = 3; i >= 0; --i)
                input.push_back((b >> i) & 1);

            inputs.push_back(input);

            int sum = a + b;
            std::vector<double> target;
            for (int i = 4; i >= 0; --i)
                target.push_back((sum >> i) & 1);

            targets.push_back(target);
        }
    }

    std::vector<int> nPerHidden = {16, 16, 12};

    Network N(8, 5, 3, nPerHidden);
    N.load("models/4bitAddition.txt");
    N.train(3000, inputs, targets, true);
    N.save("4bitAddition.txt"); */

    numPerHidden = {16, 16, 12};
    Network add(8, 5, 3, numPerHidden);
    add.load("models/4bitAddition.txt");
    res = add.predict({0, 0, 1, 1, 1, 1, 1, 0}); //  0011 + 1110
    for (int i = 0; i < res.size(); ++i)
    {
        std::cout << (res[i] < 0.5 ? 0 : 1);
    }

    return 0;
}