Ok, but what does it do, tho? You need to multithread something

yes, It generates requests for the customer and also the supplier, multithreads a queue

Ok, so what's the problem?

This

For me it is impossible to have any book on this list .... I am from Cuba so you know and well here everything is blocked

mainly on how to make sure i’m using lock semantics properly. May I dm you the pdf of the problem?

I don't know if the following is considered a personal message. Is anyone interested in learning C++ together? As in discussions and tasks and reading done together? I get bored reading a book or watching videos alone.

I am two bro

How to generate a random double between DBL_MIN and DBL_MAX in C?

https://stackoverflow.com/questions/55766058/how-can-i-generate-random-doubles-in-c

None of this examples answer my question. The solution with filling double with random bytes is incorrect, since I would like to generate the values ​​from DBL_MIN to DBL_MAX excluding nan, inf etc :(

None of this examples answer my question. The solution with filling double with random bytes is incorrect, since I would like to generate the values ​​from DBL_MIN to DBL_MAX excluding nan, inf etc :(

You can extend the solution in the first answer by checking for all the unneded cases (if isfinite doesn't cover these)

How to generate a random double between DBL_MIN and DBL_MAX in C?

Anyone know c language

assuming RAND_MAX is 1^31-1 and you're referring to DBL_MIN and DBL_MAX as biggest and smallest normalized values you could do something like this double randDouble() { union { struct { unsigned long long m : 52; unsigned long long e : 11; unsigned long long s : 1; }; unsigned long long ull; double d; } X; X.ull = rand(); X.ull <<= 0x1FLLU; X.ull |= rand(); X.s = (X.ull & (1LLU << 60)) != 0; X.e = 1 + (rand() % 0x7FEU); return X.d; }

i want to know what is the need of these 3 things. why dont we use just one way

bruh what you did with X.ull «= 0x1FLLU what's 0x1FLLU here? I mean i don't know how to work wih registers in either C or cpp so asking out of curiosity

because what you want to achieve might differ. If you ever only care about finding an exact match (same price and title) just use the first approach. However there might be a case where you don't know or don't care about the price but want to find a book with a certain title, in this case you can use a custom comparator and the generic search function. The second and third differ on how you want to use it, either you have to select the comparator at compile time (2) or you can also have it being selected dynamically via a function pointer (3).

0x1FLLU is just another way of writing (unsigned long long)31. Most libraries implement rand() returning a number between 0 and 2,147,483,647 which is 31 bits of data. Since a double is 64 bits on most platforms we need multiple rand() invocations. At first we assign the 31 bits to the a 64 bit variable and then shift it 31 bits to the left so we can fill up the lower 31 bits with the next result from rand() unsigned long long x; x = rand(); // fill the lower 31 bits with data x <<= 0x1FLLU; // move the data 31 bits to the left x |= rand(); // add another 31 bits of data now we have 62 bits of "random" data which is enough for the 53 bit of mantissa and the sign.

How do 2 and 3 differ

assuming RAND_MAX is 1^31-1 and you're referring to DBL_MIN and DBL_MAX as biggest and smallest normalized values you could do something like this double randDouble() { union { struct { unsigned long long m : 52; unsigned long long e : 11; unsigned long long s : 1; }; unsigned long long ull; double d; } X; X.ull = rand(); X.ull <<= 0x1FLLU; X.ull |= rand(); X.s = (X.ull & (1LLU << 60)) != 0; X.e = 1 + (rand() % 0x7FEU); return X.d; }

Technically this is Undefined Behavior but most implementations usually do what we expect

which part is UB?

2 and 3 are different in that 2 is more generic and can accept any callable while 3 takes in only functions

which part is UB?

All of the language

Setting X.e and returning X.d

I can't understand. 2 can take object of some class, 3 can take some function. But at the end both do the exactly same thing

2 can take any callable - it can be a class with an overloaded operator () or a normal function or a lambda or the result of a call to std::bind or the result of std::mem_fn

iirc the question was about C and it does allow type punning (in comparison to C++). But I agree, not the best style either way. I think it's easier to show the idea that way than using a couple of masks and memcpy.

If I pass a function to 2 and if it can work then why do we even use 3. I mean it's more easier to use 2 instead. In 3 I need to create a function pointer, tell the return type and argument as well, but in case of 2 I just write Comapre cmp and it's done.

Yes 2 is preferred. 3 is just a more specific case of 2. But however there is a problem with template bloating in 2 with your template being instantiated for every different callable that you call it with. This problem is not there with option 3.

What's template bloating

Multiple instantiations of your template which leads to a code bloat i.e. an increase in the size of object file generated. This is not a serious problem however. So 2 should be the preferred way

Okay and is there this thing too? If yes can you elaborate it please. "The second and third differ on how you want to use it, either you have to select the comparator at compile time (2) or you can also have it being selected dynamically via a function pointer (3)."

But I am not able to understand it😅 Only the part that I quoted

Anyway I gotta go now. If you have any questions just ask them here. Someone else might answer or I will answer later

Guys Anyone know about finite state machines?

assuming RAND_MAX is 1^31-1 and you're referring to DBL_MIN and DBL_MAX as biggest and smallest normalized values you could do something like this double randDouble() { union { struct { unsigned long long m : 52; unsigned long long e : 11; unsigned long long s : 1; }; unsigned long long ull; double d; } X; X.ull = rand(); X.ull <<= 0x1FLLU; X.ull |= rand(); X.s = (X.ull & (1LLU << 60)) != 0; X.e = 1 + (rand() % 0x7FEU); return X.d; }

But in works only on cpu with IEEE 754 floating point standard

But in works only on cpu with IEEE 754 floating point standard

The way GCC libstdc++ does it is: generate a uniformly distributed float between -1 and 1, then scale it between your low and high bounds. The reasoning is that 50% of all the space of ieee 754 space is between -1 and 1 anyway

That is, in this way it is possible to generate only half of the possible variants?

yes, but at least you will get a uniform distribution that can then be resampled and transformed

It also gives you the worst distribution in existence

Design a finite-state automaton for the alphabet Σ = {a, b} that accepts any sequence ending with at least two a or two b. Draw the state diagram, remember to show the start state and the state (s) acceptable.

Floating point numbers using IEEE 754 Standard are by nature not uniformly distributed. The question was to generate all possible representations of floating point numbers with equal likelihood. I think the solution provided by ollirz does just that. Admittedly the uniform real distribution in the C++ standard library does a better job.

So what is your question

Floating point numbers using IEEE 754 Standard are by nature not uniformly distributed. The question was to generate all possible representations of floating point numbers with equal likelihood. I think the solution provided by ollirz does just that. Admittedly the uniform real distribution in the C++ standard library does a better job.