James Dean / Negative Energy / Pyramid Schemes / Russia / The KGB / The Negative / The Positive / Ukraine / Uncategorized
0

In Formation

by admin · September 24, 2023

0 0 votes

Article Rating

Please don’t ask for an answer when I question: Are there lives on the line?

I don’t want to give an answer to that, as it could cause yet another bad thing to happen. We are pressing as hard as we can, trying to make a movement, trying to get ahead of the curve and right now it seems like we are just slightly ahead of the negative.

Trying to stop negative energy is like playing whack-a-mole without a paddle, your hand is eventually going to get sore, and it’s steady pace is eventually going to catch up to your quick pace. There’s just not anything you can do, it seems like if we could only maintain our rate of progress that that would entrust us with the answer to the question that we might like more.

I’ve been putting off updating this piece of code, i’ll post it now:

C++


// JAMES DEAN PROGRAM
//
// Version: 001
// Revision: 70
//

// 1) set each to include previous

#include "random_include/pcg_extras.hpp"
#include "random_include/pcg_random.hpp"
#include "random_include/pcg_uint128.hpp"

#include <ctime>
#include <cmath>
#include <iomanip>
#include <random>
#include <cstdlib>

#include <iostream>
#include <vector>
#include <string>

class neuron {
    private:

    signed long long int system_id = 0;
    signed long long int type_id = 0;

    std::vector<signed long long int> random_vector;
    std::vector<signed long long int> mod_vector;

    bool tier_1 = false;
    bool tier_2 = false;
    bool tier_3 = false;

    bool tier_set = false;

    void set_tier(signed long long int tier_to_set)
    {
        if(tier_to_set == 1)
        {
            tier_1 = true;

            tier_set = true;
        }

        if(tier_to_set == 2)
        {
            tier_2 = true;

            tier_set = true;
        }

        if(tier_to_set == 3)
        {
            tier_3 = true;

            tier_set = true;
        }
    }

    void set_random_vector(std::vector<signed long long int> random_input)
    {
        random_vector = random_input;
    }

    void set_mod_vector(std::vector<signed long long int> mod_input)
    {
        mod_vector = mod_input;
    }

    void set_system_id(signed long long int id_input)
    {
        system_id = id_input;
    }

    void set_type_id(signed long long int type_input)
    {
        type_id = type_input;
    }
};

class axon: public neuron {
    public:

    std::vector<neuron> neuron_lib;

    void set_neuron_lib(std::vector<neuron> neuron_input)
    {
        neuron_lib = neuron_input;
    }
};

class cranial: public neuron {
    public:

    std::vector<axon> axon_lib;

    void set_axon_lib(std::vector<axon> axon_input)
    {
        axon_lib = axon_input;
    }
};

class cortex: public neuron {
    public:

    std::vector<cranial> cranial_lib;

    void set_cranial_lib(std::vector<cranial> cranial_input)
    {
        cranial_lib = cranial_input;
    }
};

class matrix: public neuron {
    public:

    std::vector<cortex> cortex_lib;

    void set_cortex_lib(std::vector<cortex> cortex_input)
    {
        cortex_lib = cortex_input;
    }
};

class data_buff {
    public:

    signed long long int system_id = 0;
    signed long long int buff_type_id = 0;

    std::vector<signed long long int> random_vector;
    std::vector<signed long long int> mod_vector;

    void set_random_vector(std::vector<signed long long int> int_input)
    {
        random_vector = int_input;
    }

    void set_mod_vector(std::vector<signed long long int> mod_int_input)
    {
        mod_vector = mod_int_input;
    }

    void set_system_id(signed long long int system_id_input)
    {
        system_id = system_id_input;
    }

    void set_type_id(signed long long int type_id_input)
    {
        buff_type_id = type_id_input;
    }
};

class jd_raw_data {
    public:

    signed long long int system_id = 0;
    signed long long int type_id = 0;

    std::vector<data_buff*> buff_registry;

    void set_buff_registry(std::vector<data_buff*> buff_input)
    {
        buff_registry = buff_input;
    }

    void set_system_id(signed long long int system_id_input)
    {
        system_id = system_id_input;
    }

    void set_type_id(signed long long int type_id_input)
    {
        type_id = type_id_input;
    }
};

class basic_data: public jd_raw_data {
    public:

    std::vector<jd_raw_data*> raw_lib;

    void set_raw_lib(std::vector<jd_raw_data*> raw_input)
    {
        raw_lib = raw_input;
    }
};

class tier_1_data: public jd_raw_data {
    public:

    std::vector<basic_data*> basic_lib;

    void set_basic_lib(std::vector<basic_data*> basic_input)
    {
        basic_lib = basic_input;
    }
};

class tier_2_data: public jd_raw_data {
    public:

    std::vector<tier_1_data*> tier_1_lib;

    void set_tier_1_lib(std::vector<tier_1_data*> tier_1_input)
    {
        tier_1_lib = tier_1_input;
    }
};

class tier_3_data: public jd_raw_data {
    public:

    std::vector<tier_2_data*> tier_2_lib;

    void set_tier_2_lib(std::vector<tier_2_data*> tier_2_input)
    {
        tier_2_lib = tier_2_input;
    }
};

class premier_data: public jd_raw_data {
    public:

    std::vector<tier_3_data*> tier_3_lib;

    void set_tier_3_lib(std::vector<tier_3_data*> tier_3_input)
    {
        tier_3_lib = tier_3_input;
    }
};

class big_data: public jd_raw_data {
    public:

    std::vector<premier_data*> premier_lib;

    void set_premier_lib(std::vector<premier_data*> premier_input)
    {
        premier_lib = premier_input;
    }
};

class myth_data: public jd_raw_data {
    public:

    std::vector<big_data*> big_lib;

    void set_big_lib(std::vector<big_data*> big_input)
    {
        big_lib = big_input;
    }
};

std::vector<signed long long int> return_random_set();

int main(int argc, char *argv[])
{
    std::cout << "The James Dean Program\n\n";
    std::cout << "Version:001\nRevision: ??\n";
    std::cout << "-=-=--=-=--=-=--=-=--=-=--=-=--=-=--=-=-\n\n";

    std::cout << "press enter to begin\n";
    std::string local_user_input = "void";

    std::getline(std::cin, local_user_input);

    signed long long int system_id = 0;

    signed long long int raw_type_id = 0;
    signed long long int basic_type_id = 0;
    signed long long int tier_1_type_id = 0;
    signed long long int tier_2_type_id = 0;
    signed long long int tier_3_type_id = 0;
    signed long long int premier_type_id = 0;
    signed long long int big_type_id = 0;
    signed long long int myth_type_id = 0; // play myth

    signed long long int data_buff_type_id = 0;

    signed long long int raw_data_count = 0;
    signed long long int basic_data_count = 0;
    signed long long int tier_1_data_count = 0;
    signed long long int tier_2_data_count = 0;
    signed long long int tier_3_data_count = 0;
    signed long long int premier_data_count = 0;
    signed long long int big_data_count = 0;
    signed long long int myth_data_count = 0;

    signed long long int raw_data_target = 38;
    signed long long int basic_data_target = 24;
    signed long long int tier_1_data_target = 17;
    signed long long int tier_2_data_target = 9;
    signed long long int tier_3_data_target = 6;
    signed long long int premier_data_target = 4;
    signed long long int big_data_target = 3;
    signed long long int myth_data_target = 1;

    std::vector<jd_raw_data*> raw_registry;
    std::vector<basic_data*> basic_registry;
    std::vector<tier_1_data*> tier_1_registry;
    std::vector<tier_2_data*> tier_2_registry;
    std::vector<tier_3_data*> tier_3_registry;
    std::vector<premier_data*> premier_registry;
    std::vector<big_data*> big_registry;
    std::vector<myth_data*> myth_registry;

    std::vector<signed long long int> random_set_vector;
    std::vector<signed long long int> mod_set_vector;

    std::vector<signed long long int> empty_random_vector;

    std::vector<data_buff*> empty_buff_vector;

    std::vector<data_buff*> data_buff_vector;

    std::vector<jd_raw_data*> empty_raw_registry;
    std::vector<basic_data*> empty_basic_registry;
    std::vector<tier_1_data*> empty_tier_1_registry;
    std::vector<tier_2_data*> empty_tier_2_registry;
    std::vector<tier_3_data*> empty_tier_3_registry;
    std::vector<premier_data*> empty_premier_registry;
    std::vector<big_data*> empty_big_registry;
    std::vector<myth_data*> empty_myth_registry;

    signed long long int data_buff_target = 90;
    signed long long int data_buff_count = 0;

    signed long long int display_ticker = 0;
    signed long long int display_count = 0;

    bool product = true;

    while (product == true)
    {
        display_ticker = display_ticker + 1;

        if(display_ticker > 99)
        {
            std::cout << "James Dean\nSword And Shield Edition\n\n";
            
            display_ticker = 0;

            std::cout << "display_count: " << display_count << "\n";

            display_count = display_count + 1;

            std::cout << "raw_data_total: " << raw_type_id << " \traw_data_count: " << raw_data_count << "\n";
            std::cout << "basic_data_total: " << basic_type_id << " \tbasic_data_count: " << basic_data_count << "\n";
            std::cout << "tier_1_data_total: " << tier_1_type_id << " \ttier_1_data_count: " << tier_1_data_count << "\n";
            std::cout << "tier_2_data_total: " << tier_2_type_id << " \ttier_2_data_count: " << tier_2_data_count << "\n";
            std::cout << "tier_3_data_total: " << tier_3_type_id << " \ttier_3_data_count: " << tier_3_data_count << "\n";
            std::cout << "premier_data_total: " << premier_type_id << " \tpremier_data_count: " << premier_data_count << "\n";
            std::cout << "big_data_total: " << big_type_id << " \tbig_data_count: " << big_data_count << "\n";
            std::cout << "myth_data_total: " << myth_type_id << " \tmyth_data_count: " << myth_data_count << "\n";
            std::cout << "\n\n\n\n\n\n\n\n\n\n\n";
        }
        jd_raw_data new_raw_data;

        new_raw_data.set_system_id(system_id);
        system_id = system_id + 1;

        new_raw_data.set_type_id(raw_type_id);
        raw_type_id = raw_type_id + 1;

        while (data_buff_count < data_buff_target)
        {
            data_buff new_data_buff;

            new_data_buff.set_system_id(system_id);
            system_id = system_id + 1;

            new_data_buff.set_type_id(data_buff_type_id);
            data_buff_type_id = data_buff_type_id + 1;

            random_set_vector = return_random_set();

            new_data_buff.set_random_vector(random_set_vector);

            random_set_vector = empty_random_vector;

            mod_set_vector = return_random_set();

            new_data_buff.set_mod_vector(mod_set_vector);

            mod_set_vector = empty_random_vector;

            data_buff_vector.push_back(&new_data_buff);

            data_buff_count = data_buff_count + 1;
        }

        data_buff_count = 0;
        
        new_raw_data.set_buff_registry(data_buff_vector);

        data_buff_vector = empty_buff_vector;

        raw_registry.push_back(&new_raw_data);

        raw_data_count = raw_data_count + 1;

        if(raw_data_count == raw_data_target)
        {
            basic_data new_basic_data;

            raw_data_count = 0;

            new_basic_data.set_raw_lib(raw_registry);

            raw_registry = empty_raw_registry;

            new_basic_data.set_system_id(system_id);
            system_id = system_id + 1;

            new_basic_data.set_type_id(basic_type_id);
            basic_type_id = basic_type_id + 1;

            while (data_buff_count < data_buff_target)
            {
                data_buff new_data_buff;

                new_data_buff.set_system_id(system_id);
                system_id = system_id + 1;

                new_data_buff.set_type_id(data_buff_type_id);
                data_buff_type_id = data_buff_type_id + 1;

                random_set_vector = return_random_set();

                new_data_buff.set_random_vector(random_set_vector);

                random_set_vector = empty_random_vector;

                mod_set_vector = return_random_set();

                new_data_buff.set_mod_vector(mod_set_vector);

                mod_set_vector = empty_random_vector;

                data_buff_vector.push_back(&new_data_buff);

                data_buff_count = data_buff_count + 1;
            }

            data_buff_count = 0;
        
            new_basic_data.set_buff_registry(data_buff_vector);

            data_buff_vector = empty_buff_vector;

            basic_registry.push_back(&new_basic_data);

            basic_data_count = basic_data_count + 1;

            if(basic_data_count == basic_data_target)
            {
                tier_1_data new_tier_1_data;

                basic_data_count = 0;

                new_tier_1_data.set_basic_lib(basic_registry);

                basic_registry = empty_basic_registry;

                new_tier_1_data.set_system_id(system_id);
                system_id = system_id + 1;

                new_tier_1_data.set_type_id(tier_1_type_id);
                tier_1_type_id = tier_1_type_id + 1;

                while (data_buff_count < data_buff_target)
                {
                    data_buff new_data_buff;

                    new_data_buff.set_system_id(system_id);
                    system_id = system_id + 1;

                    new_data_buff.set_type_id(data_buff_type_id);
                    data_buff_type_id = data_buff_type_id + 1;

                    random_set_vector = return_random_set();

                    new_data_buff.set_random_vector(random_set_vector);

                    random_set_vector = empty_random_vector;

                    mod_set_vector = return_random_set();

                    new_data_buff.set_mod_vector(mod_set_vector);

                    mod_set_vector = empty_random_vector;

                    data_buff_vector.push_back(&new_data_buff);

                    data_buff_count = data_buff_count + 1;
                }

                data_buff_count = 0;
        
                new_tier_1_data.set_buff_registry(data_buff_vector);

                data_buff_vector = empty_buff_vector;

                tier_1_registry.push_back(&new_tier_1_data);

                tier_1_data_count = tier_1_data_count + 1;

                if(tier_1_data_count == tier_1_data_target)
                {
                    tier_2_data new_tier_2_data;

                    tier_1_data_count = 0;

                    new_tier_2_data.set_tier_1_lib(tier_1_registry);

                    tier_1_registry = empty_tier_1_registry;

                    new_tier_2_data.set_system_id(system_id);
                    system_id = system_id + 1;

                    new_tier_2_data.set_type_id(tier_2_type_id);
                    tier_2_type_id = tier_2_type_id + 1;

                    while (data_buff_count < data_buff_target)
                    {
                        data_buff new_data_buff;

                        new_data_buff.set_system_id(system_id);
                        system_id = system_id + 1;

                        new_data_buff.set_type_id(data_buff_type_id);
                        data_buff_type_id = data_buff_type_id + 1;

                        random_set_vector = return_random_set();

                        new_data_buff.set_random_vector(random_set_vector);

                        random_set_vector = empty_random_vector;

                        mod_set_vector = return_random_set();

                        new_data_buff.set_mod_vector(mod_set_vector);

                        mod_set_vector = empty_random_vector;

                        data_buff_vector.push_back(&new_data_buff);

                        data_buff_count = data_buff_count + 1;
                    }

                    data_buff_count = 0;
        
                    new_tier_2_data.set_buff_registry(data_buff_vector);

                    data_buff_vector = empty_buff_vector;

                    tier_2_registry.push_back(&new_tier_2_data);

                    tier_2_data_count = tier_2_data_count + 1;

                    if(tier_2_data_count == tier_2_data_target)
                    {
                        tier_3_data new_tier_3_data;

                        tier_2_data_count = 0;

                        new_tier_3_data.set_tier_2_lib(tier_2_registry);

                        tier_2_registry = empty_tier_2_registry;

                        new_tier_3_data.set_system_id(system_id);
                        system_id = system_id + 1;

                        new_tier_3_data.set_type_id(tier_3_type_id);
                        tier_3_type_id = tier_3_type_id + 1;

                        while (data_buff_count < data_buff_target)
                        {
                            data_buff new_data_buff;

                            new_data_buff.set_system_id(system_id);
                            system_id = system_id + 1;

                            new_data_buff.set_type_id(data_buff_type_id);
                            data_buff_type_id = data_buff_type_id + 1;

                            random_set_vector = return_random_set();

                            new_data_buff.set_random_vector(random_set_vector);

                            random_set_vector = empty_random_vector;

                            mod_set_vector = return_random_set();

                            new_data_buff.set_mod_vector(mod_set_vector);

                            mod_set_vector = empty_random_vector;

                            data_buff_vector.push_back(&new_data_buff);

                            data_buff_count = data_buff_count + 1;
                        }

                        data_buff_count = 0;
        
                        new_tier_3_data.set_buff_registry(data_buff_vector);

                        data_buff_vector = empty_buff_vector;

                        tier_3_registry.push_back(&new_tier_3_data);

                        tier_3_data_count = tier_3_data_count + 1;

                        if(tier_3_data_count == tier_3_data_target)
                        {
                            premier_data new_premier_data;

                            tier_3_data_count = 0;

                            new_premier_data.set_tier_3_lib(tier_3_registry);

                            tier_3_registry = empty_tier_3_registry;

                            new_premier_data.set_system_id(system_id);
                            system_id = system_id + 1;

                            new_premier_data.set_type_id(premier_type_id);
                            premier_type_id = premier_type_id + 1;

                            while (data_buff_count < data_buff_target)
                            {
                                data_buff new_data_buff;

                                new_data_buff.set_system_id(system_id);
                                system_id = system_id + 1;

                                new_data_buff.set_type_id(data_buff_type_id);
                                data_buff_type_id = data_buff_type_id + 1;

                                random_set_vector = return_random_set();

                                new_data_buff.set_random_vector(random_set_vector);

                                random_set_vector = empty_random_vector;

                                mod_set_vector = return_random_set();

                                new_data_buff.set_mod_vector(mod_set_vector);

                                mod_set_vector = empty_random_vector;

                                data_buff_vector.push_back(&new_data_buff);

                                data_buff_count = data_buff_count + 1;
                            }

                            data_buff_count = 0;
        
                            new_premier_data.set_buff_registry(data_buff_vector);

                            data_buff_vector = empty_buff_vector;

                            premier_registry.push_back(&new_premier_data);

                            premier_data_count = premier_data_count + 1;

                            if(premier_data_count == premier_data_target)
                            {
                                big_data new_big_data;

                                premier_data_count = 0;

                                new_big_data.set_premier_lib(premier_registry);

                                premier_registry = empty_premier_registry;

                                new_big_data.set_system_id(system_id);
                                system_id = system_id + 1;

                                new_big_data.set_type_id(big_type_id);
                                big_type_id = big_type_id + 1;

                                while (data_buff_count < data_buff_target)
                                {
                                    data_buff new_data_buff;

                                    new_data_buff.set_system_id(system_id);
                                    system_id = system_id + 1;

                                    new_data_buff.set_type_id(data_buff_type_id);
                                    data_buff_type_id = data_buff_type_id + 1;

                                    random_set_vector = return_random_set();

                                    new_data_buff.set_random_vector(random_set_vector);

                                    random_set_vector = empty_random_vector;

                                    mod_set_vector = return_random_set();

                                    new_data_buff.set_mod_vector(mod_set_vector);

                                    mod_set_vector = empty_random_vector;

                                    data_buff_vector.push_back(&new_data_buff);

                                    data_buff_count = data_buff_count + 1;
                                }

                                data_buff_count = 0;
        
                                new_big_data.set_buff_registry(data_buff_vector);

                                data_buff_vector = empty_buff_vector;

                                big_registry.push_back(&new_big_data);

                                big_data_count = big_data_count + 1;

                                if(big_data_count == big_data_target)
                                {
                                    myth_data new_myth_data;

                                    big_data_count = 0;

                                    new_myth_data.set_big_lib(big_registry);

                                    big_registry = empty_big_registry;

                                    new_myth_data.set_system_id(system_id);
                                    system_id = system_id + 1;

                                    new_myth_data.set_type_id(myth_type_id);
                                    myth_type_id = myth_type_id + 1;

                                    while (data_buff_count < data_buff_target)
                                    {
                                        data_buff new_data_buff;

                                        new_data_buff.set_system_id(system_id);
                                        system_id = system_id + 1;

                                        new_data_buff.set_type_id(data_buff_type_id);
                                        data_buff_type_id = data_buff_type_id + 1;

                                        random_set_vector = return_random_set();

                                        new_data_buff.set_random_vector(random_set_vector);

                                        random_set_vector = empty_random_vector;

                                        mod_set_vector = return_random_set();

                                        new_data_buff.set_mod_vector(mod_set_vector);

                                        mod_set_vector = empty_random_vector;

                                        data_buff_vector.push_back(&new_data_buff);

                                        data_buff_count = data_buff_count + 1;
                                    }

                                    data_buff_count = 0;
        
                                    new_myth_data.set_buff_registry(data_buff_vector);

                                    data_buff_vector = empty_buff_vector;

                                    myth_registry.push_back(&new_myth_data);

                                    myth_data_count = myth_data_count + 1;
                                }
                            }
                        }
                    }
                }
            }
        }

    }
}

std::vector<signed long long int> return_random_set()
{
    signed long long int target_number = 2'700;
    signed long long int current_number = 0;
    signed long long int random_number = 0;
    
    pcg_extras::seed_seq_from<std::random_device> seed_source;
    
    pcg64_c1024 pcg{};
    
    pcg(time(0));
    
    std::vector<signed long long int> random_set;
    
    while (current_number < target_number)
    {
        random_number = pcg();
        
        random_set.push_back(random_number);
        
        current_number = current_number + 1;
    }
    
    current_number = 0;
    
    return(random_set);
}

C++

As you can tell from the code, even if your not a programmer, we have been hard at work trying to achieve the next set of technologies, whatever that may require for us to earn, whatever.

It seems that there’s only so much you can do when you need to do much more than that, and that may be the theme of our adventure coming up, we don’t know. We’re not there yet, but we try as we can to make it a positive outcome, we do more than we think we need to do, all of it, adding up to something less than we wanted.

Why is this happening?

I don’t really have that answer, why we put in so much and it seems like it just barely gets us where we needed to be. Like we are running on borrowed time, it’s as if time is short and it grows shorter, like something growing against us, the negative energy, it would appear has taken on properties of something we used to consider, to be living.

Sure, we have policies in place, and some of us even go so far as to take to the fields, in the case of Russia, and Ukraine, they duke it out all in favor of a positive outcome. It seems that this negative that we speak of would be cornered by these tactics, instead it is left with free reign.

I tighten the noose around it’s neck further by filling in for Russia where those gaps might still remain, as if it would actually bring us the positive outcome we were so desperate for. It’s like our best was getting us something, as if to lay down a “Ten” in poker only to have it devalued for a “Seven” — i’m removing the machnism it had on us that was doing the devaluing.

I’ve got to now get back to my coding work, but I have more to say. I experience this devaluation personally, cigarettes do not cause the comfort they once did, in fact they cause nothing and I don’t know why I still smoke them. This is true for any of the other substances, they really don’t do anything, and I know why. I’ve burned my fuses out, but there’s not anyone capable of replacing them.

They can’t replace them because in fact they’ve locked in the negative that is created by my inability to use. As if that were a bad thing.

They feast on this negative, and I am left with nothing that can comfort me unless I entirely solve the puzzle, like saying, we’ll give you what you want only after we are entirely full, and it takes them a long time to eat.

So call me crazy when I point the finger at them, it’s like, don’t point the finger at us when we take away your only comforts, we’re just taking away your only comforts!

So I was supposed to throw a party? Toasting to nothing, literally nothing. Your supposed to hold value in your work, yes, but my work doesn’t pay money, in fact, it was supposed to pay in substances that comfort. That was the original deal, made years ago. They just thought, hey, it’ll be better for us if we do this to him, so it’s better for us, we can’t really think of anything greater than ourselves, …

I remember now, that was the deal. That I get to get high. In return for this work, but they took that high away. You say, that’s impossible. We left impossible behind long, long ago.

Not much incentive to work hard, is there? When your pay is literally “Less” as in, “Less” than what you had. That is not much incentive to work on this stuff… And we won’t even mention taking away an energy source, that too.

Author: admin

0 0 votes

Article Rating

Tags: C++Pyramid Schemes Russia The James Dean Program The KGB The Ukrainian War Ukraine

You may also like...

0 0 votes

Article Rating

0 Comments

Inline Feedbacks

View all comments

Personal Details

Username^*

First Name^*

Last Name^*

Email^*

Password^*

Confirm Password^*

Website^*

Biographical Info^*

How to write a general version gradient_descent algorithm in c++?
December 2, 2023 by Kato Megumi
I want to write a general version of gradient descent algorithm in c++ to pass the following gtest. ... #include TEST(HW6Test, TEST1) { auto min1 = q1::gradient_descent(0.01, 0.1, cos); EXPECT_NEAR(min1, 3.14, 0.1); auto min2 = q1::gradient_descent(0.01, 0.01, cos); EXPECT_NEAR(min2, 3.14, 0.01); } TEST(HW6Test, TEST2) { auto min = q1::gradient_descent(0.01, 0.01, [](double a){return sin(a)+cos(a);}); EXPECT_NEAR(min, -2.36, 0.01); } TEST(HW6Test, TEST3) { struct Func { double operator()(double a) {return cos(a);} }; auto min = q1::gradient_descent(0.01, 0.01, Func{}); EXPECT_NEAR(min, 3.14, 0.01); } TEST(HW6Test, TEST4) { struct Func { double operator()(double a) {return sin(a);} }; auto min = q1::gradient_descent(0.0, 0.01); EXPECT_NEAR(min, -1.57, 0.01); } […]
How to start c++ language?
December 2, 2023 by Mayank Bansal
I want to know how can I start my journey of learning C++ language and where I should start my journey, such as on YouTube or by taking a course, and what things I need to remember about learning the C++ language and which topics I should cover first so that my experience becomes better. After learning C++ for about two months, I expect to be able to answer some difficult questions about the language with ease.
How to use (double) pointer to update value of other pointer
December 2, 2023 by Tim
I am trying to merge an array of individually sorted linked lists together to one sorted linked list (this is leetcode problem 23 btw). The linked list is defined as: struct ListNode { int val; ListNode *next; ListNode() : val(0), next(nullptr) {} ListNode(int x) : val(x), next(nullptr) {} ListNode(int x, ListNode *next) : val(x), next(next) {} }; And my function look like this: ListNode* mergeKLists(vector &lists) { ListNode *head = new ListNode(-1); ListNode *current = head; while (find_if(lists.begin(), lists.end(), [](ListNode *node) { return node; }) != lists.end()) { ListNode **pSmallest = nullptr; // find smallest node value for (int i […]
How to use Windows.h Mutexes with two threads
December 2, 2023 by Timur Khalikshin
I'm facing a problem using mutexes in two different threads. I have two thread functions: a producer, which receives data from the user and writes it to a global variable, and a consumer, which receives this data from a global variable, processes it and returns it to the user. Therefore, I created two mutexes: "Information generated" and "Information processed". The first is in the “open” state when information has been received from the user and has already been recorded in a global variable, and in the “closed” state when this has not yet happened. The second is in the “open” […]
std::pair<> behaves different on debug and release builds
December 2, 2023 by gorgomit
I have a piece of code that returns an std::pair structure as below and it behaves differently on my debug and release builds std::pair: Works well in debug build, doesn’t work on release build (I get corrupted data) std::pair: Works well both in debug and release builds std::pair: reference_wrapper is created via std::cref, works well both in debug and release builds I have a logic as below (it is the version with const MyData&): std::pair MyClass::GetData() const { // MyData has some complex data and data structure in it // MyData is held in std::map myMap // Perform some searching […]
GCD in C++ using object oriented programming [closed]
December 2, 2023 by Sahil Shaikh
How to write a C++ program to find GCD of two numbers using object-oriented programming? I tried simple variable inputs and used a function, but I cannot understand the exact logic that is used in writing this program using object oriented programming.
Can someone help me fix the source code of this github file? [closed]
December 2, 2023 by Police Driver
The link is: https://github.com/rubbertoe98/vWeaponsToolkit Every time i try to compile this file, it gives me a buch of different errors (even when it is fresh) I was on a server asking someone for help. He said that it looks very broken, can someone help me check if it is indeed very broken? Because i youst cant get to compiling (Im new to)
My texture is not showing up when running the program
December 2, 2023 by firfghr25
I am having trouble with my project. Prior to adding the light features my wall texture was loading. Now it will not load when running and is just a color instead of a wall texture. I am sure that my location of the wall.jpg is correct, as this worked on my last project and I used it as my base for this project. Below is my current code: const char* texFilename = "wall.jpg"; #include #include // GLFW library #define STB_IMAGE_IMPLEMENTATION #include "stb_image.h" // Image loading Utility functions // GLM Math Header inclusions #include #include #include #include "shader.h" #include "camera.h" // […]
Clang is in a folder that does not exist on my computer? [duplicate]
December 2, 2023 by axu
I am on a MacOS (Sonoma 14.1.1) and I use VSCode to code with C++. About a week ago, the compiler unexpectedly broke, and none of my code is able to run. I tried to reinstall clang, but my terminal said it was in the folder ~/Library/Developer/CommandLineTools/usr/bin... a folder that does not exist on my computer. I can't reinstall it using xcode-select --install since my computer thinks clang already exists on my computer. I am the only person that uses this computer. Is there anything else I should try?
Cannot call functions in a DLL
December 2, 2023 by Allay466
So I want to make a shared library, and testing how it works... But I just don't understand what am I doing wrong here... main.cpp: //main.cpp #include __declspec(dllimport) int foo(int); int main() { std::cout
Can't get one SDL_Surface to blit on top of another
December 2, 2023 by czmead
I am trying to get a colored box to blit on top of a black surface that I'm using as my window background. But when I compile and run this program all I get is the black window screen: #include #include #include using namespace std; int main(int argc, char** args) { //Initializes SDL, and all subsystems if(SDL_Init(SDL_INIT_EVERYTHING) < 0) { cout
Perspective incorrect in GLFW3
December 2, 2023 by Boblet67
I am tying to make a 3D game in linux in c++ with GLFW and glad. But proper 3D perspective is not correctly working and I can't work out why. This should draw an orange triangle which gets smaller when you get further away and bigger when you get closer but it never changes size and only ends up reaching the clipping planes and disappearing. Plus, if this helps, if I have the triangle at a z of 0 I can't see it even if I move back or forth. Here is the code: #include #include "glad/glad.h" #include "GLFW/glfw3.h" #include […]
c++ how can i access virtual method in a template class which will be overriden in derived class
December 2, 2023 by Miroslav Krajcir
I have a templated Base class with 2 virtual methods begin() and end(). I also have Derived1 class, derived from Base class and Derived2 class, derived from Derived1 class. I am overriding method "begin()" in first derived class, and method "end()' in second derived class. Bud i cannot access/use the method "end()" in my first derived class. Why? #include template class Base { public: virtual T begin() = 0; virtual T end() = 0; }; template class Derived1 : public Base { public: T begin() override { return Base::end() - 10; // not working // return end() - 10; // […]
SOS flex sensor is tripping out
December 2, 2023 by DemarKo Santos
help guys, my flex sensor (this is my second attempt), doesnt work, im trying to have the flex sensor when bent at a 45 degree angle send an infared code but so far i cant even get it to turn on a light. i need help because this is my school project and im like actually about to lose my mind. code if it helps: int flexs = A0; // Flex sensor connected to analog pin A0 const int LED_PIN = 12; // LED connected to digital pin 12 void setup() { Serial.begin(9600); pinMode(LED_PIN, OUTPUT); } void loop() { int […]
Cannot find std::partial_ordering: Please include <compare> header [duplicate]
December 2, 2023 by Zebrafish
I make a module file: #include export module MyModule; export void MyFunc() { std::filesystem::exists("name"); } export class Application {public: static void func() { std::filesystem::exists("name"); } }; And then in main.cpp (non-module): import MyModule; int main() { MyFunc(); // Is FINE Application::func(); // Error Cannot find 'std::partial_ordering': Please include header return 0; } What is happening? Is it related to this bug? I'm on Version 17.7.6.
Write a class that is generic over a type parameter of type `std::size_t A` and is only able to increment its `A` by 'consuming' i.e. `std::move` it
December 2, 2023 by Jim
I want to write a C++ class with such a definition: template struct Counter { static constexpr inline std::size_t valueOfA = A; T value; }; I want to have a member function addOne(), such that it consumes itself, e.g. Counter and returns itself but of a type where its type parameter is the sum of 1 and its previous type argument, e.g. Counter. Simply put, Counter Counter.addOne(). addOne() should also consume itself such that all variables referencing to Counter should not be valid variables after addOne() is called. GodBolt The compiler error I got this: x86-64 clang 15.0.0 x86-64 clang […]
What is the issue of boost::asio async_connect in my server?
December 2, 2023 by Sourav Paul
#include #include #include #include #include #include #include "http_server.hh" using namespace boost::asio; using ip::tcp; std::string desired_IP_address = "172.16.0.2"; // For example purposes class Session : public std::enable_shared_from_this { public: Session(ip::tcp::resolver& resolver,tcp::socket socket, tcp::socket client_socket) : socket_(std::move(socket)), resolver_(resolver), client_socket_(std::move(client_socket)) {} void start() { do_read(); } private: void do_read() { auto self(shared_from_this()); socket_.async_read_some( boost::asio::buffer(data_), [this, self](boost::system::error_code ec, std::size_t length) { if (!ec) { std::string request(data_.data(), length); path_ = extract_path(request); resolver_.async_resolve( ip::tcp::resolver::query("172.16.0.4", "5000"), [this,self](const boost::system::error_code& ec, ip::tcp::resolver::iterator it) { if (ec) { std::cout
Win32 COMBOBOX dont draw dropdown-list
December 2, 2023 by Mario Rosenbohm
i create in win32 c++ plugin on a *.rc-file a COMBOBOX with drop-down-list: COMBOBOX IDC_CCODE_EDT_PNR,60,18,83,27,CBS_DROPDOWN | WS_VISIBLE | CBS_SORT | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP Create the owner window by: _hSelf = ::CreateDialogParam(_hInst, MAKEINTRESOURCE(dialogID), _hParent, dlgProc, reinterpret_cast(this)); On init requester is setting the items by: ::SendMessage(cbPointCode, CB_ADDSTRING, 0, (LPARAM)StringTools::GetWString(codes->at(i)).c_str()); On open drop-down-list is resizing okay, but items is not drawing, black text on black background. Only after mouse over is draw the item. What must i do to init drawing drop-down-list on open? regards Mario (edit add create window)
il2cpp mono dictionary stores value inside key and value is null
December 2, 2023 by Abdullah Akçam
I am creating a mod for a game that uses il2cpp backend. I have been facing a weird phenomenon. I have been iterating the m_Items array and trying to get the objects, but the weird thing is, the key stores the value and the value is NULL. void print_entities(System_Collections_Generic_Dictionary_TKey__TValue__o* pDict) { if (pDict == nullptr) return; System_Collections_Generic_Dictionary_Entry_TKey__TValue__array* entries = pDict->fields._entries; if (entries == nullptr) return; for (uint16_t i = 0; i < entries->max_length; i++) { auto entry = entries->m_Items[i]; auto obj_key = entry.fields.key; // this stores the entry.fields.value auto obj_val = entry.fields.value; // this is null } } Here is […]
Compiling ffmpeg into wasm with emscripten
December 2, 2023 by user3738243
I'm trying to integrate ffmpeg directly into my WebAssembly-project. A friend of mine provided me link to a project https://github.com/alfg/ffmpeg-webassembly-example/tree/master which does almost exactly what I'm trying to achieve. It compiles ffmpeg and creates wasm with the necessary bindings to make it usable from Javascript. But instead of building Javascript bindings - like in that example, I would like to make a single stand-alone wasm file that contains ffmpeg. I would like to use CMake for the building process and I've been trying to use that within docker similarly to how the example is built. But I'm having difficulties linking […]

In Formation

Author: admin

You may also like...

https://www.thesatellite.org/ Statistics

Last 10 Posts…

Archives

Categories

In Formation

Author: admin

You may also like...

Still Holding

Reverse

Quetzalcoatl

https://www.thesatellite.org/ Statistics

Last 10 Posts…