collect | Flexible tool for creating surveys of any type | Form library

Use older version of python (eg 3.8)

Is there a way to work around this issue without imposing additional constraints on map key and value types?

It doesn't appear doable in safe Rust, at least not with reasonable algorithmic complexity. (See Aiden4's answer for a solution that does it by re-building the whole map.)

But if you're allowed to use unsafe, and if you're determined enough that you want to delve into it, this code could do it:

I know this does not solve your problem directly, but consider moving to springdoc which most recent release supports Spring Boot 2.6.0. Springfox is so buggy at this point that is a pain to use. I've moved to springdoc 2 years ago because of its Spring WebFlux support and I am very happy about it. Additionally, it also supports Kotlin Coroutines, which I am not sure Springfox does.

If you decide to migrate, springdoc even has a migration guide.

Here is a sample code to output what you need. I use the formula below to calculate pct change. percentage_change = 100*(new-old)/old

If old is 0 it is changed to 1 to avoid division by zero error.

GCC and Clang report that S is trivially copyable in C++11 through C++23 standard modes. MSVC reports that S is not trivially copyable in C++14 through C++20 standard modes.

N3337 (~ C++11) and N4140 (~ C++14) say:

A trivially copyable class is a class that:

• has no non-trivial copy constructors,
• has no non-trivial move constructors,
• has no non-trivial copy assignment operators,
• has no non-trivial move assignment operators, and
• has a trivial destructor.

By this definition, S is trivially copyable.

N4659 (~ C++17) says:

A trivially copyable class is a class:

• where each copy constructor, move constructor, copy assignment operator, and move assignment operator is either deleted or trivial,
• that has at least one non-deleted copy constructor, move constructor, copy assignment operator, or move assignment operator, and
• that has a trivial, non-deleted destructor

By this definition, S is not trivially copyable.

N4860 (~ C++20) says:

A trivially copyable class is a class:

• that has at least one eligible copy constructor, move constructor, copy assignment operator, or move assignment operator,
• where each eligible copy constructor, move constructor, copy assignment operator, and move assignment operator is trivial, and
• that has a trivial, non-deleted destructor.

By this definition, S is not trivially copyable.

Thus, as published, S was trivally copyable in C++11 and C++14, but not in C++17 and C++20.

The change was adopted from DR 1734 in February 2016. Implementors generally treat DRs as though they apply to all prior language standards by convention. Thus, by the published standard for C++11 and C++14, S was trivially copyable, and by convention, newer compiler versions might choose to treat S as not trivially copyable in C++11 and C++14 modes. Thus, all compilers could be said to be correct for C++11 and C++14.

For C++17 and beyond, S is unambiguously not trivially copyable so GCC and Clang are incorrect. This is GCC bug #96288 and LLVM bug #39050

Take a look at the recursive formula for combinations:

Suppose you have a combination space C(n,k). You can divide that space into two subspaces:

• C(n-1,k-1) all combinations, where the first element of the original set (of length n) is present
• C(n-1, k) where first element is not preset

If you have an index X that corresponds to a combination from C(n,k), you can identify whether the first element of your original set belongs to the subset (which corresponds to X), if you check whether X belongs to either subspace:

• X < C(n-1, k-1) : belongs
• X >= C(n-1, k-1): doesn't belong

Then you can recursively apply the same approach for C(n-1, ...) and so on, until you've found the answer for all n elements of the original set.

Python code to illustrate this approach:

(Spyder maintainer here) Our regular instructions to update Spyder don't work in this case because there are some incompatible dependencies between Spyder 5.0.5 and 5.1.5.

To workaround this problem, you need to close Spyder and run the following commands in the Anaconda Prompt (or your system terminal on Linux or macOS):

I realize that the different behavior of equality (__eq__) can be actually a major concern, why such code snippet is probably not good.

However, you could maybe still do this:

This is a somewhat confusing trick to save a small amount of time:

We are creating a defaultdict with a factory function that returns a bound append method of a new list instance with [].append. Then we can just do d[key(item)](item) instead of d[key(item)].append(item) like we would have if we create a defaultdict that contains lists. If we don't lookup append everytime, we gain a small amount of time.

But now the dict contains bound methods instead of the lists, so we have to get the original list instance back via __self__.

__self__ is an attribute described for instance methods that returns the original instance. You can verify that with this for example: