comparison base/test/TestScaleTickIntervals.h @ 1460:9528c73aa98c horizontal-scale

Simpler & more consistent log scale tick calculation

     void linear_1_1_10()
     {
         // pathological range
         auto ticks = ScaleTickIntervals::linear({ 1, 1, 10 });
         ScaleTickIntervals::Ticks expected {
-            { 1.0, "1.0" }
+            { 1.0, "1" }
         };
         compareTicks(ticks, expected);
     }
     
     void linear_0_0_10()

     void log_1_10_2()
     {
         auto ticks = ScaleTickIntervals::logarithmic({ 1, 10, 2 });
         ScaleTickIntervals::Ticks expected {
             { 1.0, "1.0" },
-            { pow(10.0, 0.5), "3.2" },
-            { 10.0, "10.0" },
+            { 3.2, "3.2" },
+            { 10.0, "10" },
         };
         compareTicks(ticks, expected);
     }
     
     void log_0_10_2()

 
     void log_pi_avogadro_7()
     {
         auto ticks = ScaleTickIntervals::logarithmic({ M_PI, 6.022140857e23, 7 });
         ScaleTickIntervals::Ticks expected {
-            { 1000, "1000.0" },
+            { 1000, "1000" },
             { 1e+06, "1e+06" },
             { 1e+09, "1e+09" },
             { 1e+12, "1e+12" },
             { 1e+15, "1e+15" },
             { 1e+18, "1e+18" },

 
     void log_0p465_778_10()
     {
         auto ticks = ScaleTickIntervals::logarithmic({ 0.465, 778.08, 10 });
         ScaleTickIntervals::Ticks expected {
-            { 0.5, "0.5" },
+            { 0.5, "0.50" },
             { 1, "1.0" },
             { 2, "2.0" },
             { 4, "4.0" },
             { 8, "8.0" },
-            { 16, "16.0" },
-            { 32, "32.0" },
-            { 64, "64.0" },
-            { 128, "128.0" },
-            { 256, "256.0" },
-            { 512, "512.0" },
+            { 16, "16" },
+            { 32, "32" },
+            { 64, "64" },
+            { 130, "130" },
+            { 260, "260" },
+            { 510, "510" },
         };
         compareTicks(ticks, expected);
     }
     
     void log_1_10k_10()
     {
         auto ticks = ScaleTickIntervals::logarithmic({ 1.0, 10000.0, 10 });
         ScaleTickIntervals::Ticks expected {
             { 1.0, "1.0" },
             { 2.5, "2.5" },
-            { 6.0, "6.0" },
-            { 16.0, "16.0" },
-            { 40.0, "40.0" },
-            { 100.0, "100.0" },
-            { 250.0, "250.0" },
-            { 600.0, "600.0" },
-            { 1600.0, "1600.0" },
-            { 4000.0, "4000.0" },
+            { 6.3, "6.3" },
+            { 16.0, "16" },
+            { 40.0, "40" },
+            { 100.0, "100" },
+            { 250.0, "250" },
+            { 630.0, "630" },
+            { 1600.0, "1600" },
+            { 4000.0, "4000" },
             { 10000.0, "1e+04" },
         };
         compareTicks(ticks, expected, true);
     }
     

     void log_80_800k_10()
     {
         auto ticks = ScaleTickIntervals::logarithmic({ 80.0, 800000.0, 10 });
         ScaleTickIntervals::Ticks expected {
             { 100, "100" },
-            { 251, "251" },
-            { 631, "631" },
-            { 1580, "1580" },
-            { 3980, "3980" },
-            { 10000, "10000" },
-            { 25100, "2.5e+04" },
-            { 63100, "6.3e+04" },
+            { 250, "250" },
+            { 630, "630" },
+            { 1600, "1600" },
+            { 4000, "4000" },
+            { 10000, "1e+04" },
+            { 25000, "2.5e+04" },
+            { 63000, "6.3e+04" },
             { 160000, "1.6e+05" },
             { 400000, "4e+05" },
         };
         compareTicks(ticks, expected, true);
     }