ordered-set | mutable set that remembers the order of its entries

All data structures have their pros and cons, the reason why the standard library offers a bunch of containers.

And the rule is that there is often a balance between quickness of modifications and quickness of data extraction. Here you would like to easily access the number of elements in a range. A possibility in a tree based structure would be to cache in each node the number of elements of its subtree. That would add an average log(N) operations (the height of the tree) on each insertion or deletion, but would highly speedup the computation of the number of elements in a range. Unfortunately, few classes from the C++ standard library are tailored for derivation (and AFAIK std::set is not) so you will have to implement your tree from scratch.

First of all, as @Francois suggested, try to uninstall the CPU only version of pytorch. Also in your installation script, you should use either conda or pip3.

Then you may want to try the following attempts:

• using conda: add conda-forge channel to your command (conda install pytorch torchvision torchaudio cudatoolkit=11.1 -c pytorch -c nvidia -c conda-forge). And make sure conda is updated.
• using pip: insert --no-cache-dir into your command (pip3 --no-cache-dir install torch==1.9.0+cu111 torchvision==0.10.0+cu111 torchaudio==0.9.0 -f https://download.pytorch.org/whl/torch_stable.html) to avoid the MemoryError.

It is very likely that pip3 is pointing to a different python instance.

Imagine you had python, python3, python3.6 and python3.8 all installed on your system. Which one would pip3 install packages for? (who knows?)

It is almost always safer to do python3.8 -m pip list/install since you can be sure that python3.8 somefile.py will be using the same files you just saw. (even better, do python3.8 -m venv /path/to/some/virtualenv and then make sure that is activated, then you can be sure pip points to the same python)

The standard does not make such guarantee. The ordering is bound to be implementation-specific.

Consider this example to see why the ordering may be different even though the content is identical: let's start with two unordered sets A and B that have been created and filled with values in the same order until a point when an addition of one more object would trigger rehashing.

Now consider what happens when add an object to B, and then remove it, while not adding any objects to A. Obviously, the two sets would be identical, but since B went through rehashing, the order of the objects in these sets would change.

Section 23.2.5.12 of the C++11 standard discusses the equality of unordered containers. It states that the worst-case time complexity of figuring out the equality is O(n^2). This implies that there is no guarantee of the same ordering, because otherwise we would be able to check equality in O(n).

Use an iterator with insert().

I have solved this problem! Firstly,find the file:

EDIT: this answer just tells you how to verify what's happening in your docker image. Unfortunately I'm unable to figure out why it is happening.

How to check it?

At each step of the docker build, you can see the various layers being generated. You can use that ID to create a temporary image to check what's happening. e.g.

You can shift the verbosity into std::to_address (thanks to @Caleth for pointing that out) and the existing std::hash, which is specialized for std::unique_ptr to return a hash based on the raw address (thanks to @Mikhail for the hint). Then, implement hash and equality types with member function templates (note how you no longer need the types themselves be templates):

You need to compile with C++20 mode, i.e. with the option -std=c++2a.

Before C++20 lambda closure types have no default constructor.

Closure types are not DefaultConstructible. Closure types have no default constructor (until C++20)

If no captures are specified, the closure type has a defaulted default constructor. (since C++20)