void Chapter9Test::Test9_10() {
ofstream fout;
OpenLogFile(fout, "test9_10.html", "Problem 9.10: implement a method to build the tallest stack");
vector<size_t> solution;
double maxHeight(0.0);
// 1.
solution.clear();
maxHeight = sol.prob9_10({3.0,2.0,1.0}, {3.0,2.0,1.0}, {3.0,2.0,1.0}, solution);
TestDouble(fout, "widths: {3,2,1}, heigths: {3,2,1}, depths: {3,2,1}", maxHeight, 6.0);
TestDynamicArray(fout, "widths: {3,2,1}, heigths: {3,2,1}, depths: {3,2,1}", solution, {0,1,2});
// 2.
solution.clear();
maxHeight = sol.prob9_10({1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, \
{5.0,2.0,3.0,1.0,8.0,12.0,2.0,3.0,2.0,1.0},\
{4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}, solution);
TestDouble(fout, "widths: {1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, heigths: {5.0,2.0,3.0,1.0,8.0,12.0,2.0,3.0,2.0,1.0}, depths: {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}", maxHeight, 26.0);
TestDynamicArray(fout, "widths: {1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, heigths: {5.0,2.0,3.0,1.0,8.0,12.0,2.0,3.0,2.0,1.0}, depths: {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}", solution, {5,4,7,8,9});
// 3.
solution.clear();
maxHeight = sol.prob9_10({1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, \
{5.0,2.0,3.0,1.0,8.0,7.0,2.0,3.0,2.0,1.0},\
{4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}, solution);
TestDouble(fout, "widths: {1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, heigths: {5.0,2.0,3.0,1.0,8.0,7.0,2.0,3.0,2.0,1.0}, depths: {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}", maxHeight, 14.0);
TestDynamicArray(fout, "widths: {1.0,3.0,4.0,1.0,7.0,8.0,3.0,3.0,2.0,1.0}, heigths: {5.0,2.0,3.0,1.0,8.0,7.0,2.0,3.0,2.0,1.0}, depths: {4.0,2.0,6.0,4.0,4.0,12.0,6.0,3.0,2.0,1.0}", solution, {4,7,8,9});
CloseLogFile(fout);
}
bool C_coretestBase::TestDouble(int callbackID, const Json::Value& parameters)
{
Json::Value testDouble_JSON;
FetchObject(parameters, "testDouble", testDouble_JSON);
double testDouble;
FetchDouble(testDouble_JSON, testDouble);
TestDouble(callbackID, testDouble);
return true;
}
void test_member_data_value_function()
{
p_member_data_value_class tcl;
TestCharacter(tcl);
TestInt(tcl);
TestDouble(tcl);
TestBool(tcl);
TestPointer(tcl);
TestEnum(tcl);
TestPod(tcl);
}
main()
{
/* Alpha/OSF (at least) requires us to request that SIGFPE be ignored */
signal(SIGFPE, SIG_IGN);
/* First, some easy ones */
printf("\nEasy Ones\n");
TestDouble(1.0, 2.0);
TestDouble(5.0, 2.0);
TestHex(0x4010000000000000L, 0x400000000000001EL);
TestHex(0x4030000000000000L, 0x400E200000000000L);
/* How about negative inputs? */
printf("\nNegative Inputs\n");
TestDouble(3.0, -1.0);
TestHex(0x430000000000000FL, 0xC00E000000000000L);
TestHex(0xC00E00000000000FL, 0x430000000000000FL);
TestDouble(-1.0, -2.0);
TestHex(0xC30000000000000FL, 0x400E000000000000L);
/* How about normalization? */
printf("\nNormalization\n");
TestDouble(1.0, 1.0);
TestHex(0x400000000000000FL, 0xC000000000000000L);
/* How about rounding? */
printf("\nRounding - 1 bit\n");
TestHex(0x4010000000000000L, 0x4000000000000000L); /* 1 bit shift */
TestHex(0x4010000000000000L, 0x4000000000000001L);
TestHex(0x4010000000000001L, 0x4000000000000000L);
TestHex(0x4010000000000001L, 0x4000000000000001L);
printf("\nRounding - 2 bit\n");
TestHex(0x4020000000000000L, 0x4000000000000000L); /* 2 bit shift */
TestHex(0x4020000000000000L, 0x4000000000000001L);
TestHex(0x4020000000000000L, 0x4000000000000002L);
TestHex(0x4020000000000000L, 0x4000000000000003L);
TestHex(0x4020000000000001L, 0x4000000000000000L);
TestHex(0x4020000000000001L, 0x4000000000000001L);
TestHex(0x4020000000000001L, 0x4000000000000002L);
TestHex(0x4020000000000001L, 0x4000000000000003L);
printf("\nRounding - 3 bit\n");
TestHex(0x4030000000000000L, 0x4000000000000000L); /* 3 bit shift */
TestHex(0x4030000000000000L, 0x4000000000000001L);
TestHex(0x4030000000000000L, 0x4000000000000002L);
TestHex(0x4030000000000000L, 0x4000000000000003L);
TestHex(0x4030000000000000L, 0x4000000000000004L);
TestHex(0x4030000000000000L, 0x4000000000000005L);
TestHex(0x4030000000000000L, 0x4000000000000006L);
TestHex(0x4030000000000000L, 0x4000000000000007L);
TestHex(0x4030000000000001L, 0x4000000000000000L);
TestHex(0x4030000000000001L, 0x4000000000000001L);
TestHex(0x4030000000000001L, 0x4000000000000002L);
TestHex(0x4030000000000001L, 0x4000000000000003L);
TestHex(0x4030000000000001L, 0x4000000000000004L);
TestHex(0x4030000000000001L, 0x4000000000000005L);
TestHex(0x4030000000000001L, 0x4000000000000006L);
TestHex(0x4030000000000001L, 0x4000000000000007L);
printf("\nRounding - 4 bit\n");
TestHex(0x4040000000000000L, 0x4000000000000000L); /* 4 bit shift */
TestHex(0x4040000000000000L, 0x4000000000000001L);
TestHex(0x4040000000000000L, 0x4000000000000002L);
TestHex(0x4040000000000000L, 0x4000000000000003L);
TestHex(0x4040000000000000L, 0x4000000000000004L);
TestHex(0x4040000000000000L, 0x4000000000000005L);
TestHex(0x4040000000000000L, 0x4000000000000006L);
TestHex(0x4040000000000000L, 0x4000000000000007L);
TestHex(0x4040000000000000L, 0x4000000000000008L);
TestHex(0x4040000000000000L, 0x4000000000000009L);
TestHex(0x4040000000000000L, 0x400000000000000AL);
TestHex(0x4040000000000000L, 0x400000000000000BL);
TestHex(0x4040000000000000L, 0x400000000000000CL);
TestHex(0x4040000000000000L, 0x400000000000000DL);
TestHex(0x4040000000000000L, 0x400000000000000EL);
TestHex(0x4040000000000000L, 0x400000000000000FL);
TestHex(0x4040000000000001L, 0x4000000000000000L);
TestHex(0x4040000000000001L, 0x4000000000000001L);
TestHex(0x4040000000000001L, 0x4000000000000002L);
TestHex(0x4040000000000001L, 0x4000000000000003L);
TestHex(0x4040000000000001L, 0x4000000000000004L);
TestHex(0x4040000000000001L, 0x4000000000000005L);
TestHex(0x4040000000000001L, 0x4000000000000006L);
TestHex(0x4040000000000001L, 0x4000000000000007L);
TestHex(0x4040000000000001L, 0x4000000000000008L);
TestHex(0x4040000000000001L, 0x4000000000000009L);
TestHex(0x4040000000000001L, 0x400000000000000AL);
TestHex(0x4040000000000001L, 0x400000000000000BL);
TestHex(0x4040000000000001L, 0x400000000000000CL);
TestHex(0x4040000000000001L, 0x400000000000000DL);
TestHex(0x4040000000000001L, 0x400000000000000EL);
TestHex(0x4040000000000001L, 0x400000000000000FL);
printf("\nRounding - sticky bit, etc\n");
TestHex(0x40A0000000000000L, 0x4000000000000201L); /* test sticky bit */
TestHex(0x4007FFFFFFFFFFFFL, 0x4340000000000000L); /* again */
TestHex(0x4040000000000001L, 0x4000000000000005L); /* subtract w/sticky */
TestHex(0x40AFF80000000000L, 0x400FFFFFFFFFFFFFL); /* rounding causes
re-normalization */
TestHex(0x40AC000000000000L, 0x4004000000000005L); /* round or normalize
result first? */
/* How about zero, NaN, infinity? */
printf("\nSpecial Cases - overflow\n");
TestHex(0x7FE0000000000000L, 0x7FE0000000000000L); /* overflow to
+infinity */
TestHex(0xFFE0000000000000L, 0xFFE0000000000000L); /* overflow to
-infinity */
printf("\nSpecial Cases - NaN in\n");
TestHex(0x7FF0000000000001L, 0x3FF0000000000000L); /* NaN plus 1 */
TestHex(0x3FF0000000000000L, 0x7FF1000000000000L); /* 1 plus NaN */
printf("\nSpecial Cases - NaN out\n");
TestHex(0x7FF0000000000000L, 0xFFF0000000000000L); /* +Infinity plus
-Infinity */
printf("\nSpecial Cases - Infinity in\n");
TestHex(0x7FF0000000000000L, 0x3FF0000000000000L); /* +Infinity plus 1 */
TestHex(0x7FF0000000000000L, 0xBFF0000000000000L); /* +Infinity plus -1 */
TestHex(0xFFF0000000000000L, 0x3FF0000000000000L); /* -Infinity plus 1 */
TestHex(0xFFF0000000000000L, 0xBFF0000000000000L); /* -Infinity plus -1 */
printf("\nSpecial Cases - zero\n");
TestDouble(0.0, 1.0);
TestDouble(1.0, -1.0);
printf("\nDone.\n");
}
