Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[MorleyDev]

I think I just accomplished a scarily nice looking way to do composite Assertions in natural language for my C++ Unit Testing library.

Code: [Select]

AssertThat(12, Is::LessThan(15) && Is::GreaterThan(13));
AssertThat(28, Is::LessThan(13) || Is::GreaterThan(19));
AssertThat(15, !(Is::LessThan(13) || Is::GreaterThan(19)));
AssertThat(15, Is::Not::LessThan(13) && Is::Not::GreaterThan(19));

So much template wizardry have I learned, but at least the Macro wizardry is limited to like 5 functions at the highest level only that don't read too horribly...C++11, you so awesome

[Mego]

I think I just accomplished a scarily nice looking way to do composite Assertions in natural language for my C++ Unit Testing library.

Code: [Select]

AssertThat(12, Is::LessThan(15) && Is::GreaterThan(13));
AssertThat(28, Is::LessThan(13) || Is::GreaterThan(19));
AssertThat(15, !(Is::LessThan(13) || Is::GreaterThan(19)));
AssertThat(15, Is::Not::LessThan(13) && Is::Not::GreaterThan(19));

So much template wizardry have I learned, but at least the Macro wizardry is limited to like 5 functions at the highest level only that don't read too horribly...C++11, you so awesome

I believe I almost see what you did and it's clever. How did you handle the boolean operators? Snazzy overloads?

[MorleyDev]

Snazzy overloads and template metaprogramming to put them onto a CRTP base class. There are generic AndOperand, OrOperand and NotOperand functions that combine the "natural language assertion" constraints appropriately, with overloaded operators on the base class to call them. Also means brackets and such still work for operator precedence.

Kinda surprised it works, to be honest. But both VS2013 and GCC compile it. Overloading the boolean && and || operators does remove short-circuiting, but in the use cases here that's not really a concern. It's something I'd never do in "production" code, naturally, but for a testing library? Yes, I believe this is an acceptable allowance.

Basically the whole library is 90% template metaprogramming and 10% the actual fixture logic.

A basic test fixture looks like this: https://gist.github.com/MorleyDev/5362664
The functions needed to describe tests taking lambdas mean I don't need to do the macro hacks to setup a test like older unit testing libraries, such as CPPUnit, UnitTest++ and Google Test. The whole point of the library was more or less to prove C++11's capabilities for cleaner, less macro-heavy code and that proper testing is perfectly possible in C++.

And of course the tests for the library are examples of how to do more complex tests since they're all written using the library

[Mego]

Snazzy overloads and template metaprogramming to put them onto a CRTP base class. There are generic AndOperand, OrOperand and NotOperand functions that combine the "natural language assertion" constraints appropriately, with overloaded operators on the base class to call them. Also means brackets and such still work for operator precedence.

Kinda surprised it works, to be honest. But both VS2013 and GCC compile it. Overloading the boolean && and || operators does remove short-circuiting, but in the use cases here that's not really a concern. It's something I'd never do in "production" code, naturally, but for a testing library? Yes, I believe this is an acceptable allowance.

Basically the whole library is 90% template metaprogramming and 10% the actual fixture logic.

A basic test fixture looks like this: https://gist.github.com/MorleyDev/5362664
The functions needed to describe tests taking lambdas mean I don't need to do the macro hacks to setup a test like older unit testing libraries, such as CPPUnit, UnitTest++ and Google Test. The whole point of the library was more or less to prove C++11's capabilities for cleaner, less macro-heavy code and that proper testing is perfectly possible in C++.

And of course the tests for the library are examples of how to do more complex tests since they're all written using the library

That is an extremely clever use of CRTP. Kudos to you, good sir.

[MorleyDev]

The main debate I'm having right now is whether or not to provide a xor overload. C++ doesn't have a logical xor, just bitwise ^. But the reason for that appears to be that x != y is the same as x xor y for booleans, and that ^ can't be short-circuited.

But since & and | can't be short-circuited, should I instead be providing Constraint & Constraint instead of Constraint && Constraint? Except I *do* have limited short-circuiting at the moment, since Constraint && Constraint will only call the first constraint if it fails, at least until it tries to figure out the error message to print. But Constraint && !Constraint will still not the latter constraint before producing the AndOperand...

[dreadmullet]

I have discovered a case where floats are more accurate than doubles:

Code: (C++) [Select]

#include <iostream>

int main(int numArgs , char** args){
   
   int testInt1 = ((0.1d + 0.7d) * 10);
   int testInt2 = ((0.1f + 0.7f) * 10);
   
   std::cout << "testInt1 = " << testInt1 << '\n';
   std::cout << "testInt2 = " << testInt2 << '\n';
   
   return 0;
   
}

Code: (Output) [Select]

testInt1 = 7
testInt2 = 8

[Skyrunner]

Very interesting.

For my edited code (to facilitate debugging)

Code: [Select]

#include <iostream>

using namespace std;

int main()
{
double d1 = 0.1;
double d2 = 0.7;
float f1 = 0.1f;
float f2 = 0.7f;
double doubleMiddle = ((d1 + d2) * 10);
float floatMiddle = ((f1 + f2) * 10);
int result1 = doubleMiddle;
int result2 = floatMiddle;

cout << "Doubles: " << result1 << endl;
cout << "Float: " << result2 << endl;
cin.get();
}
Peering into the locals with MSVS tells me that...

Code: [Select]

d1 0.10000000000000001 double
d2 0.69999999999999996 double
f1 0.10000000 float
f2 0.69999999 float
doubleMiddle 7.9999999999999991 double
floatMiddle 8.0000000 float
So yeah, the extra precision granted is actually hurting the overall precision. The added value is just shy of 8, so the int value is 7.

(incidentally, I think this is why you aren't supposed to compare floats directly. xD)

[Soadreqm]

Because the numbers are all stored in base two, you can only accurately represent powers of two.
0.1₂ = 2^-1₁₀ = 0.5₁₀
0.00101₂ = 2^-3₁₀ + 2^-5₁₀ = 0.15625₁₀
0.1₁₀ = 0.00011001100110011...₂

So, yeah. Never directly compare floats. If the language you're working in doesn't come with one, code your own is-this-number-within-a-certain-range-of-this-other-number function and use that instead. And if you really need flawless precision, use integers for everything. It doesn't come up in most applications, but if the number represents someone's bank account balance or something, it's sometimes better to play it safe.

[Skyrunner]

N-body sim

I just made some quick changes to it.

The main problems I have are two.

(1) The cluster kinda floats off-screen, as you can see between 69 and 205 steps, and I can't think of a way to make it scroll easily and painlessly. x3

(2) It runs at 2 fps at 3000 particles. I want more particles. MOAR
Currently it's only single-threaded, so I might be able to multithread it for a cheap and easy x4 speedup. Still only'd be 12000 8000 particles...

[alway]

For 1, add in an offset for the camera/display. Have the offset be based on the average position of the points, to keep the average position in the center. So offset = avgPos - viewDimensions/2. And then simply something like:

Code: [Select]

GetRenderPoint(pos)
{
   return pos - offset;
}

[Skyrunner]

I actually made the offset be manually controlled by the person viewing it, but the main problem is that (because how Allegro handles key events) if the FPS can't be kept up because it takes to long to sim, it becomes unresponsive.

Here's a crude video I took of 1000 objects. Funnily, it doesn't look like one thousand. Maybe it's because like half of them fly off within 50 steps.
edit: video of 4000 objects. It's suddenly a lot slower (n^2 complexity killed the cat), but it also looks a lot more interesting. Darnit :<

One problem with the average offset I can think of is that if the entire cluster spreads in more than one direction, you'll be staring at a blank space.

edit2: I just realized I was listening to music while taking that video It's kinda appropriate, though. To life, to life! I'll bring them back to life!

[Rose]

Well, multi-threading the physics processing will instantly let you scroll around without the physics slowing down the graphical FPS

[Dutchling]

Err, does anyone know what this means/is?

Code: [Select]

>>> 0x1
1
>>> 0x2
2
>>> 0x100
256
>>> 0x200
512
>>> 0x3
3
>>> 0x4
4
>>> 0x4
4
>>> 0x34
52
>>> 0x700
1792
>>> 0x43
67
>>> 0x654
1620

[Rose]

looks like a hex to decimal converter.

[ECrownofFire]

I actually made the offset be manually controlled by the person viewing it, but the main problem is that (because how Allegro handles key events) if the FPS can't be kept up because it takes to long to sim, it becomes unresponsive.

http://gafferongames.com/game-physics/fix-your-timestep/

Err, does anyone know what this means/is?
-snip-

That's a CLI for some scripting language (Python?).