k1k4ss0's questions

I have a simple chat over classic Bluetooth. The implementation is in Android/Java.

Problem

The whole mechanism works, in fact it allows you to send a message and it is received correctly. The only thing that when sending a second and third message... is not sent, however, I have seen that the log shows the following error:

W/IInputConnectionWrapper: beginBatchEdit on inactive InputConnection
    getTextBeforeCursor on inactive InputConnection
W/IInputConnectionWrapper: getTextAfterCursor on inactive InputConnection
W/IInputConnectionWrapper: getSelectedText on inactive InputConnection
W/IInputConnectionWrapper: endBatchEdit on inactive InputConnection
W/IInputConnectionWrapper: beginBatchEdit on inactive InputConnection

From what I understand is that the socket is somehow inactive and decides to close the Input communication.

Code

The code I have to send the messages is the following:

This method is used to obtain the elements of the chat, read what is in a EditTextmessage that I am going to send and when clicking on the send button it will transmit it over socket

  private void init(){
    listMainchat = findViewById(R.id.lista_conversacion);
    edCreateMessage = findViewById(R.id.mensaje_entrada);
    btnSendMessage = findViewById(R.id.btn_send_msg);

//  Adaptador para poder indrucir elementos a la lista de la conmversacion
    adapterMainChat = new ArrayAdapter<String>(context,R.layout.message_layout);
    listMainchat.setAdapter(adapterMainChat);

    btnSendMessage.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View view) {
        String message = edCreateMessage.getText().toString();
        if(!message.isEmpty()){
          edCreateMessage.setText(null);
          chatUtils.write(message.getBytes());
        }
      }
    });
  }

This message is received by the following method: Which creates a Thread that manages the connection already established between both devices

 public void write(byte[] buffer){
    ConnectedThread conThread;
    synchronized (this){
      if(state != STATE_CONNECTED){
        return;
      }
      conThread= connectedThread;
    }
    conThread.write(buffer);
  }

   public void write(byte[] buffer){
      try {
        outputStream.write(buffer);
        handler.obtainMessage(MainActivity.MESSAGE_WRITE,-1,-1,buffer).sendToTarget();
      }catch (IOException e){}
    }

Edit

Searching in the Logs I have found this message in acatch

E/Connect->Run: java.io.IOException: read failed, socket might closed or timeout, read ret: -1

What comes out of the Thread constructor of the socket connection:

private class ConnectThread extends Thread{

    private final BluetoothSocket socket;
    private final BluetoothDevice device;
//  Constructor del Thread, recibimos un device
    public ConnectThread(BluetoothDevice device){
//  creamos un socket para el dispositivo remoto a travez de Bluetooth clasico (BD/EDR)
      this.device = device;
      BluetoothSocket tmp = null;
      try{
        tmp = device.createRfcommSocketToServiceRecord(APP_UUID);
      }catch (IOException e){
        Log.e("Connect->constructor", e.toString());
      }
      socket = tmp;
    }

    public void run (){
//  Intentamos conectar al socket del dispositivo remoto
      try{
        socket.connect();
      }catch (IOException e_){
        Log.e("Connect->Run", e_.toString());
        try{
          Log.d("La ejecucion del trhead ha sido interrumpida",", vamos a cerrar el socket");
          socket.close();
        }catch (IOException e){
          Log.e("Connect->CloseSocket", e.toString());
        }
        connectionFailed();
        return;
      }

      synchronized (ChatUtils.this){
        connectThread = null;
      }
//    Terminamos de conectar y notificamos al sistema de que estamos conectados
      connected(socket,device);
    }


    public void cancel(){
      try {
        socket.close();
      }catch (IOException e){
        Log.e("Connect->Cancel", e.toString());
      }
    }
  }

I am making a program in C++ in which I have to multiply two matrices, however when I create the method operator*and test it (being empty), it gives me the error that it puts in the title:

main.cpp:28:20: error: invalid operands of types ‘matrix<float>*’ and ‘matrix<float>*’ to binary ‘operator*’
matrix<float>* b=a*a;
                 ~^~

What I have in the main is the following:

#include <iostream>
#include <exception>
using namespace std;
#include "excepciones.hpp"
#include "matrix.cpp"


int main (){

    matrix<float>* a;
    int x=0, y=0;
    cout<<"introduzca el numero de filas de la matriz:"<<endl;
    cin>> x;
    cout<<"introduzca el numero de columnas de la matriz:"<<endl;
    cin>>y;

    try{

        a=new matrix<float> (x,y);
    }

    catch(exception& e){

        cout<<e.what()<<endl;
    }
    matrix<float>* b=a*a;


}

and the operator* method is as follows:

template <class T>
matrix<T>* matrix<T>::operator*(matrix<T>* a){

    return NULL;

}

In hpp it is defined as follows:

matrix<T>* operator*(matrix<T>* a);

It shouldn't work, because the type of object to be multiplied is specified in the method, (being fine), and for now, it returns NULL, which is a value that the pointer bcan accept without problems

I am trying to prove with the pumping lemma if the expression described in the title is a regular language or not, this is what I have tried:

∑={a,b}

∃(w)∈L y w = a^i b^j a  , siendo i,j>=0

|w| = 2n+1 >=n , cumple la condicion de |w| >= n

We know that w = xyzwith which:

|xy| <= n   ^   1 <= |y| <= n

Being X=a^p, y=a^qand that p+q<=n I would stay in the endz=a^(n-p-q) b^n a

This way it would stay|w|= p+q+n-p-q+n+1

checking the property of: x y^j z ∈ Lfor all j >=0, we have to create a new chain with j=2: w' = x y^2 zwith which it would be:

p + 2q + n - p - q + n + 1 =  2n + 1

In the end it is simplified to: q+2n+1 = 2n+1 that is only true if q=0which cannot be since the property of the pumping lemma itself says1<=|y|<=n

What I don't understand is that if I apply this with a string, for example:

w = aaaba

With n=2we can divide winto:

x=a
y=a
z=aba

With which for any y^ithat occurs to us as long as it is >=0, it should be accepted, since it ends in ano ??

I want to make a query that in theory (and wrong for practical purposes) would be something like this

select A,MAX(COUNT(B)) from Tabla group by A;

However I know this doesn't work. For MAX(count(op)) to work, you would have to put it alone, that is, it would be something like this:

select MAX(COUNT(OP)) from Tabla group by A;

However, I require the A attribute associated with MAX(...).

How could I do it? Doing something analogous to the first thing, I get the following error:

 ORA-00937: not a single-group group function

I have the following table:

mysql> select * from Hospital;
+---+-----------+------------+
| H | PR        | F          |
+---+-----------+------------+
| 1 | Canarias  | 1984-02-01 |
| 2 | Cataluña  | 1996-04-03 |
| 3 | Canarias  | 2010-03-01 |
| 4 | Madrid    | 1999-01-01 |
| 5 | Madrid    | 2019-12-01 |
+---+-----------+------------+
5 rows in set (0.00 sec)

And I want to get the "H" in Madrid with the oldest date, so I use the following query:

mysql> select H,min(F) from Hospital where PR="Madrid" group by H;
+---+------------+
| H | min(F)     |
+---+------------+
| 4 | 1999-01-01 |
| 5 | 2019-12-01 |
+---+------------+
2 rows in set (0.00 sec)

The issue is that it shows me two tuples, and I need the one with H=4, because it shows two tuples instead of 1?

With the "Describe" command the following is output:

mysql> describe Hospital;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| H     | varchar(5)  | NO   | PRI | NULL    |       |
| PR    | varchar(10) | NO   |     | NULL    |       |
| F     | date        | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

I have a practice and when reading it, the doubt arose that it is an abstract class?

So my question is... that, what is an abstract class or what does it consist of

I am making a hash table, in which each cell has several keys, what I have done is an object called cell in which the different keys of the table are stored as an array. Inside the table object, in turn, I have a vector of cells. The problem is that I have this code:

In the hash table object

#define Tablon
#include <vector>

template <class T >

class Tabla{

private:
std::vector<T> vCelda;
int size;

public:

Tabla(int n_celdas,int s_celda/*,int f_disp,int f_exp*/):

    vCelda(n_celdas,celda(s_celda))
    {
    }

in the cell object

template <class T>
class celda{

    private:
        int  nClaves;
        T* claves;
        int libres;
    public:

        celda(int nC ){

            nClaves=nC;
            claves = new T [nClaves];
            libres=nClaves; 
        }

vCelda=new celda<T> [n_celdas] (s_celda) ;

When I compile it to see if it's ok it gives me the following error:

In file included from main.cpp:3:0:
tabla.hpp: In constructor ‘Tabla<T>::Tabla(int, int)’:
tabla.hpp:20:26: error: missing template arguments before ‘(’ token
     vCelda(n_celdas,celda(s_celda))

If I put the following line:

vCelda(n_celdas,celda<T>(s_celda))

The following error is thrown:

 In file included from main.cpp:3:0:
 tabla.hpp: In instantiation of ‘Tabla<T>::Tabla(int, int) [with T = DNI]’:
 main.cpp:39:37:   required from here
 tabla.hpp:20:38: error: no matching function for call to ‘std::vector<DNI, std::allocator<DNI> >::vector(int&, celda<DNI>)’
      vCelda(n_celdas,celda<T>(s_celda))
                                  ^

I have tried removing the parameter in parentheses, but obviously it gives another error, since there is no empty default constructor. I'm wondering if C++ contains any predefined ways to perform these types of operations.

Hello, I am making a code with templates, and when I compile it I get the following error:

    main.cpp: In function ‘int main()’:
    main.cpp:41:28: error: ‘class number<char, 0, 10>’ has no member named ‘make_op’
             case '+': number_T.make_op(operacion);break;
                                ^~~~~~~
    main.cpp:42:28: error: ‘class number<char, 0, 10>’ has no member named ‘make_op’
             case '-': number_T.make_op(operacion);break;
                                ^~~~~~~
    main.cpp:43:28: error: ‘class number<char, 0, 10>’ has no member named ‘make_op’
             case '*': number_T.make_op(operacion);break;
                                ^~~~~~~
    main.cpp:44:28: error: ‘class number<char, 0, 10>’ has no member named ‘make_op’
             case '/': number_T.make_op(operacion);break;
                                ^~~~~~~
    main.cpp:45:28: error: ‘class number<char, 0, 10>’ has no member named ‘make_op’
             case '=': number_T.make_op(operacion);break;
                                ^~~~~~~
    main.cpp:46:28: error: ‘class number<char, 0, 10>’ has no member named ‘make_op’
             case '<': number_T.make_op(operacion);break;
                                ^~~~~~~
    main.cpp:47:28: error: ‘class number<char, 0, 10>’ has no member named ‘make_op’
             case '>': number_T.make_op(operacion);break;
                                ^~~~~~~

The code in the main that you mention is the following:

    switch(operacion){                                      // ejecutamos las operaciones

        case '+': number_T.make_op(operacion);break;
        case '-': number_T.make_op(operacion);break;
        case '*': number_T.make_op(operacion);break;
        case '/': number_T.make_op(operacion);break;
        case '=': number_T.make_op(operacion);break;
        case '<': number_T.make_op(operacion);break;
        case '>': number_T.make_op(operacion);break;
    }

And the file that contains the object and the method is the following:

#include <iostream>
#include <cmath>
using namespace std;
template < class T, size_t N, size_t B >

class number{

    private:
    T* digitos; 
    int index;
    int base;
    int val1,val2;
    int final=0;
    int size;
    public:



    void s_base(int i){
        base=i;

    }       
    void set_vals(int a, int b){
        val1=a;
        val2=b;

    }


    number(T valor):digitos(NULL){
       resize_v(N);
       int sz = sizeof(valor);
       resize_v(sz);       
    }


    void resize_v(int sz){

        digitos = new T [sz];
        size=sz;
        index = sz -1;
    }


    int longitud(int number) const{

            return ceil(log(number)/log(base));  // usa la libreria math.h

    }



    void set_base(int n ){
        if(n>=base){
            int result = n / base;             // obtenemos el valor resultado de la divicion, para la llamada recursiva
            int rest = n % base;               // obtenemos el resto, para guardarlo en el vector
            if(rest > 9 ){                  // en caso que el numero dado sea mayor que 9, hay que representarlo en caracteres alfabeticos
                rest+=55;                    // si rest = 10, 10 + 55 = 65 === 'A'
                digitos[index]=(char)rest;
            }
            else{
                rest+=48;
                digitos[index]=(char)rest;
            }
            index--;                        // disminuimos el indice del vector
            set_base(result);               // llamada recursiva
        }


        else{
            if(n > 9 ){                  // en caso que el numero dado sea mayor que 9, hay que representarlo en caracteres alfabeticos
                n+=55;                    // si rest = 10, 10 + 55 = 65 === 'A'
                digitos[index]=(char)n;
            }
            else{
                n+=48;
                digitos[index]=(char)n;
            }
            digitos[index]=n;                 // al llegar al ultimo valor en el que no se pueda dividir por la base, se inserta en la posicion mas
            index=0;                        // significativa
        }
    }

    void make_op(char op){

        int result=0;
        switch(op){

        case '+':  result=val1+val2;resize_v(longitud(result));set_base(result);break;
        case '-':  result=val1-val2;resize_v(longitud(result));set_base(result);break;
        case '*':  result=val1*val2;resize_v(longitud(result));set_base(result);break;
        case '/':  result=val1/val2;resize_v(longitud(result));set_base(result);break;
        case '=':  val1==val2 ? cout<<"Son iguales"<<endl : cout<<"No son iguales"<<endl;break;
        case '<':  val1<val2 ? cout<<"El primer valor es menor"<<endl : cout<<"El primer valor es mayor";break;
        case '>':  val1>val2 ? cout<<"El primer valor es mayor"<<endl : cout<<"El primer valor es menor"<<endl;break;

        }

    }
    int get_result(){
        if(index>0){

            int result=int(digitos[index]);
            result>=55 ? result-55 : result-48;
            int a=pow(base,index);
            index--;

            final=get_result()+ result*a;

            return final;
        }

    }


    ostream& write(ostream& os)const{

        for(int i = 0; i <= size; i++){
            cout << " | " << digitos[i];
        }
        cout<< endl;

    }   
};

I have a code for a neural network, and when I test it from time to time it gives me New recent average error: -nan. I'm guessing it's something like a "double" number out of range or something like that, when I go into the debugger and see the value of the double variable it comes out 0xfffffffffff. The code is :

    // neural-net-tutorial.cpp
    // David Miller, http://millermattson.com/dave
    // See the associated video for instructions: http://vimeo.com/19569529


    #include <vector>
    #include <iostream>
    #include <cstdlib>
    #include <cassert>
    #include <cmath>
    #include <fstream>
    #include <sstream>

    using namespace std;

    // Silly class to read training data from a text file -- Replace This.
    // Replace class TrainingData with whatever you need to get input data into the
    // program, e.g., connect to a database, or take a stream of data from stdin, or
    // from a file specified by a command line argument, etc.

    class TrainingData
    {
    public:
        TrainingData(const string filename);
        bool isEof(void) { return m_trainingDataFile.eof(); }
        void getTopology(vector<unsigned> &topology);

        // Returns the number of input values read from the file:
        unsigned getNextInputs(vector<double> &inputVals);
        unsigned getTargetOutputs(vector<double> &targetOutputVals);

    private:
        ifstream m_trainingDataFile;
    };

    void TrainingData::getTopology(vector<unsigned> &topology)
    {
        string line;
        string label;

        getline(m_trainingDataFile, line);
        stringstream ss(line);
        ss >> label;
        if (this->isEof() || label.compare("topology:") != 0) {
            abort();
        }

        while (!ss.eof()) {
            unsigned n;
            ss >> n;
            topology.push_back(n);
        }

        return;
    }

    TrainingData::TrainingData(const string filename)
    {
        m_trainingDataFile.open(filename.c_str());
    }

    unsigned TrainingData::getNextInputs(vector<double> &inputVals)
    {
        inputVals.clear();

        string line;
        getline(m_trainingDataFile, line);
        stringstream ss(line);

        string label;
        ss>> label;
        if (label.compare("in:") == 0) {
            double oneValue;
            while (ss >> oneValue) {
                inputVals.push_back(oneValue);
            }
        }

        return inputVals.size();
    }

    unsigned TrainingData::getTargetOutputs(vector<double> &targetOutputVals)
    {
        targetOutputVals.clear();

        string line;
        getline(m_trainingDataFile, line);
        stringstream ss(line);

        string label;
        ss>> label;
        if (label.compare("out:") == 0) {
            double oneValue;
            while (ss >> oneValue) {
                targetOutputVals.push_back(oneValue);
            }
        }

        return targetOutputVals.size();
    }


    struct Connection
    {
        double weight;
        double deltaWeight;
    };


    class Neuron;

    typedef vector<Neuron> Layer;

    // ****************** class Neuron ******************
    class Neuron
    {
    public:
        Neuron(unsigned numOutputs, unsigned myIndex);
        void setOutputVal(double val) { m_outputVal = val; }
        double getOutputVal(void) const { return m_outputVal; }
        void feedForward(const Layer &prevLayer);
        void calcOutputGradients(double targetVal);
        void calcHiddenGradients(const Layer &nextLayer);
        void updateInputWeights(Layer &prevLayer);

    private:
        static double eta;   // [0.0..1.0] overall net training rate
        static double alpha; // [0.0..n] multiplier of last weight change (momentum)
        static double transferFunction(double x);
        static double transferFunctionDerivative(double x);
        static double randomWeight(void) { return rand() / double(RAND_MAX); }
        double sumDOW(const Layer &nextLayer) const;
        double m_outputVal;
        vector<Connection> m_outputWeights;
        unsigned m_myIndex;
        double m_gradient;
    };

    double Neuron::eta = 0.15;    // overall net learning rate, [0.0..1.0]
    double Neuron::alpha = 0.5;   // momentum, multiplier of last deltaWeight, [0.0..1.0]


    void Neuron::updateInputWeights(Layer &prevLayer)
    {
        // The weights to be updated are in the Connection container
        // in the neurons in the preceding layer

        for (unsigned n = 0; n < prevLayer.size(); ++n) {
            Neuron &neuron = prevLayer[n];
            double oldDeltaWeight = neuron.m_outputWeights[m_myIndex].deltaWeight;

            double newDeltaWeight =
                    // Individual input, magnified by the gradient and train rate:
                    eta
                    * neuron.getOutputVal()
                    * m_gradient
                    // Also add momentum = a fraction of the previous delta weight;
                    + alpha
                    * oldDeltaWeight;

            neuron.m_outputWeights[m_myIndex].deltaWeight = newDeltaWeight;
            neuron.m_outputWeights[m_myIndex].weight += newDeltaWeight;
        }
    }

    double Neuron::sumDOW(const Layer &nextLayer) const
    {
        double sum = 0.0;

        // Sum our contributions of the errors at the nodes we feed.

        for (unsigned n = 0; n < nextLayer.size() - 1; ++n) {
            sum += m_outputWeights[n].weight * nextLayer[n].m_gradient;
        }

        return sum;
    }

    void Neuron::calcHiddenGradients(const Layer &nextLayer)
    {
        double dow = sumDOW(nextLayer);
        m_gradient = dow * Neuron::transferFunctionDerivative(m_outputVal);
    }

    void Neuron::calcOutputGradients(double targetVal)
    {
        double delta = targetVal - m_outputVal;
        m_gradient = delta * Neuron::transferFunctionDerivative(m_outputVal);
    }

    double Neuron::transferFunction(double x)
    {
        // tanh - output range [-1.0..1.0]

        return tanh(x);
    }

    double Neuron::transferFunctionDerivative(double x)
    {
        // tanh derivative
        return 1.0 - x * x;
    }

    void Neuron::feedForward(const Layer &prevLayer)
    {
        double sum = 0.0;

        // Sum the previous layer's outputs (which are our inputs)
        // Include the bias node from the previous layer.

        for (unsigned n = 0; n < prevLayer.size(); ++n) {
            sum += prevLayer[n].getOutputVal() *
                    prevLayer[n].m_outputWeights[m_myIndex].weight;
        }

        m_outputVal = Neuron::transferFunction(sum);
    }

    Neuron::Neuron(unsigned numOutputs, unsigned myIndex)
    {
        for (unsigned c = 0; c < numOutputs; ++c) {
            m_outputWeights.push_back(Connection());
            m_outputWeights.back().weight = randomWeight();
        }

        m_myIndex = myIndex;
    }


    // ****************** class Net ******************
    class Net
    {
    public:
        Net(const vector<unsigned> &topology);
        void feedForward(const vector<double> &inputVals);
        void backProp(const vector<double> &targetVals);
        void getResults(vector<double> &resultVals) const;
        double getRecentAverageError(void) const { return m_recentAverageError; }

    private:
        vector<Layer> m_layers; // m_layers[layerNum][neuronNum]
        double m_error;
        double m_recentAverageError;
        static double m_recentAverageSmoothingFactor;
    };


    double Net::m_recentAverageSmoothingFactor = 100.0; // Number of training samples to average over


    void Net::getResults(vector<double> &resultVals) const
    {
        resultVals.clear();

        for (unsigned n = 0; n < m_layers.back().size() - 1; ++n) {
            resultVals.push_back(m_layers.back()[n].getOutputVal());
        }
    }

    void Net::backProp(const vector<double> &targetVals)
    {
        // Calculate overall net error (RMS of output neuron errors)

        Layer &outputLayer = m_layers.back();
        m_error = 0.0;

        for (unsigned n = 0; n < outputLayer.size() - 1; ++n) {
            double delta = targetVals[n] - outputLayer[n].getOutputVal();
            m_error += delta * delta;
        }
        m_error /= outputLayer.size() - 1; // get average error squared
        m_error = sqrt(m_error); // RMS

        // Implement a recent average measurement

        m_recentAverageError =
                (m_recentAverageError * m_recentAverageSmoothingFactor + m_error)
                / (m_recentAverageSmoothingFactor + 1.0);

        // Calculate output layer gradients

        for (unsigned n = 0; n < outputLayer.size() - 1; ++n) {
            outputLayer[n].calcOutputGradients(targetVals[n]);
        }

        // Calculate hidden layer gradients

        for (unsigned layerNum = m_layers.size() - 2; layerNum > 0; --layerNum) {
            Layer &hiddenLayer = m_layers[layerNum];
            Layer &nextLayer = m_layers[layerNum + 1];

            for (unsigned n = 0; n < hiddenLayer.size(); ++n) {
                hiddenLayer[n].calcHiddenGradients(nextLayer);
            }
        }

        // For all layers from outputs to first hidden layer,
        // update connection weights

        for (unsigned layerNum = m_layers.size() - 1; layerNum > 0; --layerNum) {
            Layer &layer = m_layers[layerNum];
            Layer &prevLayer = m_layers[layerNum - 1];

            for (unsigned n = 0; n < layer.size() - 1; ++n) {
                layer[n].updateInputWeights(prevLayer);
            }
        }
    }

    void Net::feedForward(const vector<double> &inputVals)
    {
        assert(inputVals.size() == m_layers[0].size() - 1);

        // Assign (latch) the input values into the input neurons
        for (unsigned i = 0; i < inputVals.size(); ++i) {
            m_layers[0][i].setOutputVal(inputVals[i]);
        }

        // forward propagate
        for (unsigned layerNum = 1; layerNum < m_layers.size(); ++layerNum) {
            Layer &prevLayer = m_layers[layerNum - 1];
            for (unsigned n = 0; n < m_layers[layerNum].size() - 1; ++n) {
                m_layers[layerNum][n].feedForward(prevLayer);
            }
        }
    }

    Net::Net(const vector<unsigned> &topology)
    {
        unsigned numLayers = topology.size();
        for (unsigned layerNum = 0; layerNum < numLayers; ++layerNum) {
            m_layers.push_back(Layer());
            unsigned numOutputs = layerNum == topology.size() - 1 ? 0 : topology[layerNum + 1];

            // We have a new layer, now fill it with neurons, and
            // add a bias neuron in each layer.
            for (unsigned neuronNum = 0; neuronNum <= topology[layerNum]; ++neuronNum) {
                m_layers.back().push_back(Neuron(numOutputs, neuronNum));
                cout << "Made a Neuron!" << endl;
            }

            // Force the bias node's output to 1.0 (it was the last neuron pushed in this layer):
            m_layers.back().back().setOutputVal(1.0);
        }
    }


    void showVectorVals(string label, vector<double> &v)
    {
        cout << label << " ";
        for (unsigned i = 0; i < v.size(); ++i) {
            cout << v[i] << " ";
        }

        cout << endl;
    }


    int main()
    {
        TrainingData trainData("/tmp/trainingData.txt");

        // e.g., { 3, 2, 1 }
        vector<unsigned> topology;
        trainData.getTopology(topology);

        Net myNet(topology);

        vector<double> inputVals, targetVals, resultVals;
        int trainingPass = 0;

        while (!trainData.isEof()) {
            ++trainingPass;
            cout << endl << "Pass " << trainingPass;

            // Get new input data and feed it forward:
            if (trainData.getNextInputs(inputVals) != topology[0]) {
                break;
            }
            showVectorVals(": Inputs:", inputVals);
            myNet.feedForward(inputVals);

            // Collect the net's actual output results:
            myNet.getResults(resultVals);
            showVectorVals("Outputs:", resultVals);

            // Train the net what the outputs should have been:
            trainData.getTargetOutputs(targetVals);
            showVectorVals("Targets:", targetVals);
            assert(targetVals.size() == topology.back());

            myNet.backProp(targetVals);

            // Report how well the training is working, average over recent samples:
            cout << "Net recent average error: "
                    << myNet.getRecentAverageError() << endl;
        }

        cout << endl << "Done" << endl;
    }

The file to which it refers to collect the samples is the result of the following code:

    #include <iostream>
    #include <cmath>
    #include <cstdlib>

    using namespace std;
    int main(){


        cout <<"topology: 2 4 1"<<endl;
        for(int i =2000; i>=0;--i){

            int n1 =(int)(2.0*rand()/double(RAND_MAX));
            int n2 =(int)(2.0*rand()/double(RAND_MAX));
            int t = n1 ^ n2;
            cout <<"in: "<<n1 << ".0 "<<n2 <<".0 "<<endl;
            cout <<"out: "<<t<<".0"<<endl;

        }
    }

I have a database in which I have, among others, 3 tables. The first contains user data, the second contains the relationship between a university major and its subjects, and the last contains the subjects themselves.

Total would have something like this:

    mysql> describe users;
    +------------+------------------+------+-----+-------------------+----------------+
    | Field      | Type             | Null | Key | Default           | Extra          |
    +------------+------------------+------+-----+-------------------+----------------+
    | id         | int(10) unsigned | NO   | PRI | NULL              | auto_increment |
    | name       | varchar(255)     | NO   |     | NULL              |                |
    | email      | varchar(255)     | NO   | UNI | NULL              |                |
    | password   | varchar(255)     | NO   |     | NULL              |                |
    | id_uni     | int(11)          | NO   | MUL | NULL              |                |
    | id_car     | int(11)          | NO   | MUL | NULL              |                |
    | created_at | timestamp        | NO   |     | CURRENT_TIMESTAMP |                |
    +------------+------------------+------+-----+-------------------+----------------+
    7 rows in set (0.00 sec)

    mysql> describe unicars;
    +--------------+---------+------+-----+---------+----------------+
    | Field        | Type    | Null | Key | Default | Extra          |
    +--------------+---------+------+-----+---------+----------------+
    | id           | int(11) | NO   | PRI | NULL    | auto_increment |
    | id_uni       | int(11) | NO   | MUL | NULL    |                |
    | id_car       | int(11) | NO   | MUL | NULL    |                |
    | id_asig      | int(11) | NO   | MUL | NULL    |                |
    | cuatrimestre | int(11) | NO   |     | NULL    |                |
    | ano          | int(11) | NO   |     | NULL    |                |
    +--------------+---------+------+-----+---------+----------------+
    6 rows in set (0.00 sec)

    mysql> describe asignaturas;
    +------------+--------------+------+-----+---------+----------------+
    | Field      | Type         | Null | Key | Default | Extra          |
    +------------+--------------+------+-----+---------+----------------+
    | id         | int(11)      | NO   | PRI | NULL    | auto_increment |
    | asignatura | varchar(200) | NO   |     | NULL    |                |
    +------------+--------------+------+-----+---------+----------------+
    2 rows in set (0.00 sec)

The content of these tables is as follows:

    mysql> select * from users;
    +----+---------+---------+----------+--------+--------+---------------------+
    | id | name    | email   | password | id_uni | id_car | created_at          |
    +----+---------+---------+----------+--------+--------+---------------------+
    |  1 | k1k4ss0 | jaja@gg | password |      1 |      1 | 2019-01-20 22:53:49 |
    +----+---------+---------+----------+--------+--------+---------------------+
    1 row in set (0.00 sec)

    mysql> select * from unicars;
    +----+--------+--------+---------+--------------+-----+
    | id | id_uni | id_car | id_asig | cuatrimestre | ano |
    +----+--------+--------+---------+--------------+-----+
    |  1 |      1 |      1 |       1 |            1 |   2 |
    |  2 |      1 |      1 |       2 |            1 |   2 |
    |  3 |      1 |      1 |       3 |            1 |   2 |
    |  4 |      1 |      1 |       4 |            1 |   2 |
    |  5 |      1 |      1 |       5 |            1 |   2 |
    |  6 |      1 |      1 |       6 |            2 |   2 |
    |  7 |      1 |      1 |       7 |            2 |   2 |
    |  8 |      1 |      1 |       8 |            2 |   2 |
    |  9 |      1 |      1 |       9 |            2 |   2 |
    | 10 |      1 |      1 |      10 |            2 |   2 |
    +----+--------+--------+---------+--------------+-----+
    10 rows in set (0.00 sec)

    mysql> select * from asignaturas;
    +----+---------------------------------------------+
    | id | asignatura                                  |
    +----+---------------------------------------------+
    |  1 | Sistemas Operativos                         |
    |  2 | Ingles Tecnico                              |
    |  3 | Estructura de Computadores                  |
    |  4 | Estadistica                                 |
    |  5 | Computabilidad y Algoritmia                 |
    |  6 | Redes y Sistemas Distribuidos               |
    |  7 | Codigo Deontologico y Aspectos Legales      |
    |  8 | Algoritmos y Estructuras de Datos Avanzadas |
    |  9 | Administracion de Sistemas                  |
    | 10 | Fundamentos de Ingenieria del Software      |
    +----+---------------------------------------------+
    10 rows in set (0.00 sec)

    mysql> select * from unis;
    +----+--------------------------+
    | id | universidad              |
    +----+--------------------------+
    |  1 | Universidad de la Laguna |
    +----+--------------------------+
    1 row in set (0.00 sec)

The issue is that I can't find a way to make a query that shows me for a user all the subjects of his career and his university.

I have tried the following query:

select name,universidad,carrera,asignatura,cuatrimestre 
from users natural join unicars natural join asignaturas natural join 
carreras natural join unis order by cuatrimestre,asignatura asc;

but it gives me the following result:

  +-----------+--------------------------+------------------------+---------------------+--------------+
    | name    | universidad              | carrera                | asignatura          | cuatrimestre |
    +---------+--------------------------+------------------------+---------------------+--------------+
    | k1k4ss0 | Universidad de la Laguna | Ingenieria Informatica | Sistemas Operativos |            1 |
    +---------+--------------------------+------------------------+---------------------+--------------+
    1 row in set (0.00 sec)

What I want is something similar to this:

    +---------------------------------------------+--------------+
    | asignatura                                  | cuatrimestre |
    +---------------------------------------------+--------------+
    | Computabilidad y Algoritmia                 |            1 |
    | Estadistica                                 |            1 |
    | Estructura de Computadores                  |            1 |
    | Ingles Tecnico                              |            1 |
    | Sistemas Operativos                         |            1 |
    | Administracion de Sistemas                  |            2 |
    | Algoritmos y Estructuras de Datos Avanzadas |            2 |
    | Codigo Deontologico y Aspectos Legales      |            2 |
    | Fundamentos de Ingenieria del Software      |            2 |
    | Redes y Sistemas Distribuidos               |            2 |
    +---------------------------------------------+--------------+
    10 rows in set (0.00 sec)

With the difference that it shows the name of the user.

I'm making a page with bootstrap, and my question is:

How do I do so if I have a bootstrap element, and I want it to stay in a fixed position regardless of whether there is a scroll or not.

example:

<head>
    <title> Take a note </title>

    <link rel="stylesheet" href="css/lateral.css"> 
    <link rel="stylesheet" href="css/bootstrap.min.css">
    <script src="js/bootstrap.min.js"> </script>

</head>
<body>

<!--  barra de arriba -->
<div class="fixed-top">
<nav class="navbar navbar-expand-lg navbar-light bg-light barra">
  <a class="navbar-brand" href="#">Takeanote</a>
  <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarNavAltMarkup" aria-controls="navbarNavAltMarkup" aria-expanded="false" aria-label="Toggle navigation">
    <span class="navbar-toggler-icon"></span>
  </button>
  <div class="collapse navbar-collapse" id="navbarNavAltMarkup">
    <div class="navbar-nav">
      <a class="nav-item nav-link active" href="#">Home <span class="sr-only">(current)</span></a>
      <a class="nav-item nav-link" href="#">Features</a>
      <a class="nav-item nav-link" href="#">Pricing</a>
      <a class="nav-item nav-link disabled" href="#" tabindex="-1" aria-disabled="true">Disabled</a>
    </div>
   </div> 

<div>
        <p style="position:relative;padding-right:5px;">imagen</p>
    </div>


   <div>

    <p style="position:relative;padding-right:0px;">usuario</p>
    </div>


</nav>
</div>
<!--  panel lateral -->

<div class="sidenav">
  <a href="#">Mis Apuntes</a>
  <a href="#">Favoritos</a>


 </br>
 <a href="#">Apuntes</a>
 <a href="#">Documentos</a>
 <a href="#">Ejercicios</a>
 <a href="#">Practicas</a>

</div>

<!--  campo normal, el contenido vamos  -->
<div style="padding-left: 10%" class="sticky-top">


<div style="margin-top: 55px;position:sticky;">
<nav aria-label="breadcrumb " >
  <ol class="breadcrumb">
    <li class="breadcrumb-item"><a href="#">ULL</a></li>
    <li class="breadcrumb-item"><a href="#">Informatica</a></li>
    <li class="breadcrumb-item active" aria-current="page">Sistemas Operativos</li>
  </ol>
</nav>
</div>

<table class="table">
  <thead>
    <tr>

      <th scope="col">Nombre</th>
      <th scope="col">tipo de archivo</th>
      <th scope="col">usuario</th>
      <th scope="col">valoracion</th>
    </tr>
  </thead>
  <tbody>

    <tr>

      <td>Tema1.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>1138</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>papadomcmenu</td>
      <td>996</td>
    </tr>
    <tr>
      <td>Bash1</td>
      <td>practica</td>
      <td>santikiller32</td>
      <td>660</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>600</td>
    </tr>
    <tr>
      <td>bash2</td>
      <td>practica</td>
      <td>Tostadorav2</td>
      <td>540</td>
    </tr>
    <tr>

      <td>Tema1.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>1138</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>papadomcmenu</td>
      <td>996</td>
    </tr>
    <tr>
      <td>Bash1</td>
      <td>practica</td>
      <td>santikiller32</td>
      <td>660</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>600</td>
    </tr>
    <tr>
      <td>bash2</td>
      <td>practica</td>
      <td>Tostadorav2</td>
      <td>540</td>
    </tr>
    <tr>

      <td>Tema1.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>1138</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>papadomcmenu</td>
      <td>996</td>
    </tr>
    <tr>
      <td>Bash1</td>
      <td>practica</td>
      <td>santikiller32</td>
      <td>660</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>600</td>
    </tr>
    <tr>
      <td>bash2</td>
      <td>practica</td>
      <td>Tostadorav2</td>
      <td>540</td>
    </tr>
    <tr>

      <td>Tema1.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>1138</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>papadomcmenu</td>
      <td>996</td>
    </tr>
    <tr>
      <td>Bash1</td>
      <td>practica</td>
      <td>santikiller32</td>
      <td>660</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>600</td>
    </tr>
    <tr>
      <td>bash2</td>
      <td>practica</td>
      <td>Tostadorav2</td>
      <td>540</td>
    </tr>
    <tr>

      <td>Tema1.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>1138</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>papadomcmenu</td>
      <td>996</td>
    </tr>
    <tr>
      <td>Bash1</td>
      <td>practica</td>
      <td>santikiller32</td>
      <td>660</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>600</td>
    </tr>
    <tr>
      <td>bash2</td>
      <td>practica</td>
      <td>Tostadorav2</td>
      <td>540</td>
    </tr>
    <tr>

      <td>Tema1.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>1138</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>papadomcmenu</td>
      <td>996</td>
    </tr>
    <tr>
      <td>Bash1</td>
      <td>practica</td>
      <td>santikiller32</td>
      <td>660</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>600</td>
    </tr>
    <tr>
      <td>bash2</td>
      <td>practica</td>
      <td>Tostadorav2</td>
      <td>540</td>
    </tr>
    <tr>

      <td>Tema1.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>1138</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>papadomcmenu</td>
      <td>996</td>
    </tr>
    <tr>
      <td>Bash1</td>
      <td>practica</td>
      <td>santikiller32</td>
      <td>660</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>600</td>
    </tr>
    <tr>
      <td>bash2</td>
      <td>practica</td>
      <td>Tostadorav2</td>
      <td>540</td>
    </tr>
    <tr>

      <td>Tema1.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>1138</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>papadomcmenu</td>
      <td>996</td>
    </tr>
    <tr>
      <td>Bash1</td>
      <td>practica</td>
      <td>santikiller32</td>
      <td>660</td>
    </tr>
    <tr>
      <td>Tema2.pdf</td>
      <td>apunte</td>
      <td>k1k4ss0</td>
      <td>600</td>
    </tr>
    <tr>
      <td>bash2</td>
      <td>practica</td>
      <td>Tostadorav2</td>
      <td>540</td>
    </tr>
  </tbody>
</table>

</div>



<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q" crossorigin="anonymous"></script>
</body>


</html>

I have two horizontal navigation bars and I need them to be static and the entries do scroll

CSS:

body {
      font-family: "Lato", sans-serif;
    }
    .barra{
      padding-top: 0%;
     position: fixed;
    }

    /*   panel lateral  */
    .sidenav {

      height: 100%;
      width: 10%;
      position: fixed;
      left: 0;
      background-color: #1111;
      overflow-x: hidden;
      padding-top: 10px;
    }

    /*     las letras dentro del panel      */
    .sidenav a {
      padding-left:10%;
      padding-top:5px;
      text-decoration: none;
      font-size: 17px;
      color: #818181;
      display: block;

    }

    .sidenav a:hover {
      color: #f1f1f1;
    }
    .main {

      width:match-parent;

    }

    @media screen and (max-height: 450px) {
      .sidenav {padding-top: 15px;}
      .sidenav a {font-size: 18px;}
    }

Well, when I execute code in javascript and I have a string like for example:

 var variable="esto es una . cadena con punto".search(".");

Well, it gives 0, I have searched and apparently search() returns 0 when it does not have parameters or they are not initialized, something that I do not understand because I am explicitly passing the string that it has to search for...

I have a javascript code that accesses firebase to obtain information and then inserts html code with said information. All this does but not as expected. For example, images are used but instead of putting them with a specific size, it puts them at the maximum size, occupying the entire screen. Another thing would be the letters that instead of being written in white are put in a gray color. And of course everything is disorganized.

I was wondering if it was something I hadn't accounted for, or just something I'm doing wrong, so here's the code:

.
.
.
<div class="container-fluid">
<div class="card-group" id="ejemplo"> 







<script src="https://www.gstatic.com/firebasejs/5.7.2/firebase.js"></script>
<script>
// Initialize Firebase
var config = {
.
.
.
.
};
firebase.initializeApp(config);

var database = firebase.database();
var numerojaja=-1;


var aaaa= firebase.database().ref("/peliculas/");          // hacemos una referencia al nodo de peliculas


aaaa.once("value",function(snapshot){            // accedemos a la base de datos 

var vector=[];                           // creamos un vector

snapshot.forEach(function(child){        // por cada hijo de "peliculas"

vector.push(child.key);          // pusheamos dicho hijo, ya que esta en orden ascendente

});      
// window.alert("hola");
var ejemplo = document.getElementById("ejemplo");                                            // una vez terminado la obtencion de los indices de los hijos de "peliculas"
for(var i = vector.length-1; i>=0;i--){       // hacemos un bucle para acceder al vector en orden inverso

aaaa.child(vector[i]).once('value').then(function(snapshot){     // accedemos al hijo que tiene el identificador de la ultima posicion del vector


ejemplo.insertAdjacentHTML("beforeend",'<div class="col-xs-12 col-sm-6  col-md-4  col-lg-3">');
ejemplo.insertAdjacentHTML("beforeend",'<div class="card">');
ejemplo.insertAdjacentHTML("beforeend",'<img class="card-img-top" src="'+snapshot.val().cartelera+'" alt="Card image cap" >');
ejemplo.insertAdjacentHTML("beforeend",'<div class="card-body">');
ejemplo.insertAdjacentHTML("beforeend",'<p class="card-title"> '+snapshot.val().nombre+'</p>');
ejemplo.insertAdjacentHTML("beforeend",'<i class="descripcion">'+snapshot.val().descripcion+'</i>');
ejemplo.insertAdjacentHTML("beforeend",'<br>');
ejemplo.insertAdjacentHTML("beforeend",'<i class="cocos">'+snapshot.val().reputacion+' cocos sobre 5</i>');
ejemplo.insertAdjacentHTML("beforeend",'</div>');
ejemplo.insertAdjacentHTML("beforeend",'</div>');
ejemplo.insertAdjacentHTML("beforeend",'</div>');





});                                                                                                  

}                                                                                                      
});                                                                                      




</script>

I also have as it should be the tags in html, but with the data locally (this way everything works fine).

<div class="col-xs-12 col-sm-6  col-md-4  col-lg-3">
<div class="card">
<img class="card-img-top" src="imagenes/ep1.jpg" alt="Card image cap" >
<div class="card-body">
<p class="card-title"> Star Wars Episodio 1, la amenaza fantasma</p>
<i class="descripcion">Dual of fates.</i>
<br>
<i class="cocos">3 cocos sobre 5</i>
</div>
</div>
</div>

In the css file I have:

    body {

      background-color: #0F171E;
       min-height: 100%;
            min-width: 800px;

            /* Escalamiento proporcional */
            width: 100%;
            height: auto;



    }

    .navbar{
        background-color:rgba(000, 000, 000, 0.4);
        color:white;



    }



    .cocos{
        font-size:10px;

    }

    .descripcion{
        font-size:20px;

    }

    .card-title{
        font-size:25px;



    }

    .card{
        background-color:rgba(255, 255, 255, 0.0);
        width: 18rem;
        color:white;
        font-family:trebuchet-ms;
    }

I'm programming in javascript (I'm new) and I've noticed that sometimes it doesn't run sequentially, I've seen that it's because it runs asynchronously.

So far I've kind of gotten away with the setTimeout function, but I'd like to know if there are other ways to control the execution of javascript so it does exactly what I want.

In my particular case, I have this code where I access firebase to obtain the number of children of a node:

      firebase.initializeApp(config);

      var database = firebase.database();


             var numerojaja;
             //     TO-DO : obtener el numero de peliculas  
           firebase.database().ref('/peliculas/').once('value').then(function(snapshot) {  

               numerojaja=snapshot.numChildren();
               console.log(numerojaja);
           });

             console.log(numerojaja);

             //                 **********
             var numero_p=3;        // de momento 
             var nombre_p="hhola";
             var descripcion="esto es una descripcion";
             var reputacion="y esto una reputacion";
             var cartelera="esto es una direccion de una imagen";


             // for(etc.......){
             document.write('<tr>');
             document.write('<th scope="row">'+nombre_p+'</th>');
             document.write('<td>'+descripcion+' </td>');
             document.write('<td>'+reputacion+'</td>');
             document.write('<td><img src="'+direccion+'" class=".img-responsive" alt="Cinque Terre " style="max-width: 20%;"> </td>');
             document.write('</tr>');

             // end for.......

The problem is within the following section of code:

             var numerojaja;
             //     TO-DO : obtener el numero de peliculas  
           firebase.database().ref('/peliculas/').once('value').then(function(snapshot) {  

               numerojaja=snapshot.numChildren();
               console.log(numerojaja);
           });

Javascript first decides to skip execution inside the function and continues, and once it has finished executing the rest, it executes the function. Making that when I want to access that value I can't because it hasn't been executed yet.

Thank you very much.

I am making a web page in which I use booststrap and firebase. Total that I have the form to collect user data to later send it to firebase to add it to the database.

I have searched for information on why it does not work (the data is not uploaded to the database), but I have not found anything, the html code is as follows:

    <html>
        <meta charset="UTF-8">
        <head>

            <title>Casco cines</title>
            <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
            <link rel="stylesheet" href="rectk_complicaciones.css" type="text/css" />
            <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js" integrity="sha384-ChfqqxuZUCnJSK3+MXmPNIyE6ZbWh2IMqE241rYiqJxyMiZ6OW/JmZQ5stwEULTy" crossorigin="anonymous"></script>
            <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
            <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.3/umd/popper.min.js" integrity="sha384-ZMP7rVo3mIykV+2+9J3UJ46jBk0WLaUAdn689aCwoqbBJiSnjAK/l8WvCWPIPm49" crossorigin="anonymous"></script>



        </head>



        <body>



           <nav class="navbar navbar-expand-lg navbar-light bg-light">
           <a class="navbar-brand" href="Index.html">Casco cines</a>

           <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarTogglerDemo02" aria-controls="navbarTogglerDemo02" aria-expanded="false" aria-label="Toggle navigation">

              <span class="navbar-toggler-icon"></span>

           </button>

           <div class="collapse navbar-collapse" id="navbarTogglerDemo02">


                <ul class="navbar-nav mr-auto mt-2 mt-lg-0">
                <li class="nav-item active">

                  <a class="nav-link" href="Top.html">Top <span class="sr-only">(current)</span></a>

                </li>
                <li class="nav-item active">

                    <a class="nav-link" href="categoria.html">Categoria <span class="sr-only">(current)</span></a>

                </li>
                <li class="nav-item active">

                    <a class="nav-link" href="at_cliente.html">Atención al cliente <span class="sr-only">(current)</span></a>

                </li>

                </ul>


                <form class="form-inline my-2 my-lg-0">


                  <a class="navbar-brand" href="login.html">Log in</a>




                </form>


            </div>


        </nav>




        <div>  
           <!-- aca va un espacio -->
           </br>




        </div>
            <div id="SignIn">

                <div class="container">
                    <div id="SignIn-row" class="row justify-content-center align-items-center">
                        <div id="SignIn-column" class="col-md-6">
                            <div class="SignIn-box col-md-12">


                                <form id="SignIn-form" class="form" action="" method="post">
                                    <h3 class="text-center text-info text-dark ">Sign In</h3>


                                    <div class="form-group">
                                        <label for="name" class="text-info text-dark">Name:</label><br>
                                        <input type="text" name="name" id="name" class="form-control">
                                    </div>

                                    <div class="form-group">
                                        <label for="surname" class="text-info text-dark">Surname:</label><br>
                                        <input type="text" name="surname" id="surname" class="form-control">
                                    </div>

                                    <div class="form-group">
                                        <label for="email" class="text-info text-dark">Email:</label><br>
                                        <input type="text" name="email" id="email" class="form-control">
                                    </div>

                                    <div class="form-group">
                                        <label for="inputPassword" class="text-info text-dark">Password:</label><br>
                                        <input type="password" class="form-control" id="inputPassword">
                                    </div>

                                    <div class="form-group">
                                        <label for="repeatpassword" class="text-info text-dark">Repeat Password:</label><br>
                                        <input type="password" class="form-control" id="repeatpassword">
                                    </div>

                                    <div class=" text-center form-group ">


                                        <button type="button" id="end-pls" onClick="aux()" class="btn btn-danger">Registrate</button>

                                       <!-- <script src="https://www.gstatic.com/firebasejs/5.7.2/firebase.js"></script> -->
                                        <script src="https://www.gstatic.com/firebasejs/4.12.1/firebase.js"></script>
                                        <script src="https://www.gstatic.com/firebasejs/4.12.1/firebase-firestore.js"></script>
                                        <script>   // Initialize Firebase


                                          var config = {
                                            apiKey: "XXXXXXXXXXX",
                                            authDomain: "xxxxxxxxx",
                                            databaseURL: "xxxxxxxxxxx",
                                            projectId: "xxxxxxxx",
                                            storageBucket: "xxxxxx-xxxxxx.appspot.com",
                                            messagingSenderId: "xxxxxx"
                                          };
                                          firebase.initializeApp(config);

                                          var db= firebase.firestore();



                                         const btn = document.getElementById("end-pls");

                                         btn.addEventListener('click',e=>{

                                         const name = document.getElementById("name").value;
                                         const surname = document.getElementById("surname").value;
                                         const pass=document.getElementById("pass");
                                         const email = document.getElementById("email");




                                          db.collection("Usuarios").add({
                                                name: name,
                                                surname:surname,
                                                pass: pass,
                                                email:email
                                            })
                                            .then(function(docRef) {
                                                console.log("Document written with ID: ", docRef.id);
                                            })
                                            .catch(function(error) {
                                                console.error("Error adding document: ", error);
                                            });

                                             });




                                        </script>
                                    </div>





                        </form>
                    </div>
                </div>
            </div>
        </div>
    </div>




        </body>

    </html>

In firestone I have the following rules:

    service cloud.firestore {
      match /databases/{database}/documents {
        match /{document=**} {
          allow read, write;
        }
      }
    }

And finally, in the data I have in the "Usuarios" collection, in document "0" (but my idea is that they are created automatically, that's why I try to use collection(...).add) and the collection would be :email, name, pass, surname.

Many thanks in advance for all the help.

In my code I am making a graph where I am saving states and I have to, of course, interconnect all of them. I have already repeated the code like 4 times and it always gives me the same error. The code is the following:

graph.hpp

#ifndef _boii_


#define _boii_

#include <set>
#include "state.hpp"
using namespace std;
class grafo{
    private:

    set<state> my_states;



    public:
    grafo();
    ~grafo();
    void set_states(int i);

};




#endif 

graph.cpp

#include "grafo.hpp"


grafo::grafo(){}

grafo::~grafo(){}


void grafo::set_states(int i){
    state a;
    a.set_id(i);
    my_states.insert(a);

}

and node.hpp

#ifndef _qwerty_

 #define _qwerty_


#include <vector>
#include <iostream>


  using namespace std;
class state{

private:

int id;
bool acepted;



public:

state();
~state();
int get_id();
bool get_acpt();

void set_id(int i);
void set_acpt(bool i);

 int operator < (const state& a);

  };



 #endif

I will only show the operator of the node object, since it is where the error is being generated, and also that the rest of the libraries are simple sets and gets. the perator < would be:

int state::operator < (const state& a){
    if(id < a.id){
        return 1;
    }

    return 0;

}

Finally, the error that I always get is this:

In file included from /usr/include/c++/4.8/bits/stl_tree.h:63:0,
                 from /usr/include/c++/4.8/set:60,
                 from grafo.hpp:6,
                 from grafo.cpp:1:
/usr/include/c++/4.8/bits/stl_function.h: In instantiation of ‘bool std::less<_Tp>::operator()(const _Tp&, const _Tp&) const [with _Tp = state]’:
/usr/include/c++/4.8/bits/stl_tree.h:1324:11:   required from ‘std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_unique_pos(const key_type&) [with _Key = state; _Val = state; _KeyOfValue = std::_Identity<state>; _Compare = std::less<state>; _Alloc = std::allocator<state>; std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::key_type = state]’  


/usr/include/c++/4.8/bits/stl_tree.h:1377:47:   required from ‘std::pair<std::_Rb_tree_iterator<_Val>, bool> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_insert_unique(const _Val&) [with _Key = state; _Val = state; _KeyOfValue = std::_Identity<state>; _Compare = std::less<state>; _Alloc = std::allocator<state>]’


/usr/include/c++/4.8/bits/stl_set.h:463:29:   required from ‘std::pair<typename std::_Rb_tree<_Key, _Key, std::_Identity<_Key>, _Compare, typename _Alloc::rebind<_Key>::other>::const_iterator, bool> std::set<_Key, _Compare, _Alloc>::insert(const value_type&) [with _Key = state; _Compare = std::less<state>; _Alloc = std::allocator<state>; typename std::_Rb_tree<_Key, _Key, std::_Identity<_Key>, _Compare, typename _Alloc::rebind<_Key>::other>::const_iterator = std::_Rb_tree_const_iterator<state>; std::set<_Key, _Compare, _Alloc>::value_type = state]’
grafo.cpp:12:23:   required from here


/usr/include/c++/4.8/bits/stl_function.h:235:20: error: passing ‘const state’ as ‘this’ argument of ‘int state::operator<(const state&)’ discards qualifiers [-fpermissive]
       { return __x < __y; }
                    ^

state.cpp:26:38: error: no ‘int state::operator<(const state&)’ member function declared in class ‘state’
 int state::operator < (const state& a){
                                      ^

I would really appreciate any help, and thanks in advance.