go-hep.org/x/hep@v0.38.1/hplot/internal/talbot/labelling_test.go (about)

     1  // Copyright ©2020 The go-hep Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Copyright ©2017 The Gonum Authors. All rights reserved.
     6  // Use of this source code is governed by a BSD-style
     7  // license that can be found in the LICENSE file.
     8  
     9  package talbot
    10  
    11  import (
    12  	"math"
    13  	"reflect"
    14  	"testing"
    15  )
    16  
    17  var talbotLinHanrahanTests = []struct {
    18  	dMin, dMax  float64
    19  	want        int
    20  	containment int
    21  
    22  	wantValues    []float64
    23  	wantStep      float64
    24  	wantMagnitude int
    25  }{
    26  	// Expected values confirmed against R reference implementation.
    27  	{
    28  		dMin:        -1.9846500878911073,
    29  		dMax:        0.4370974820125605,
    30  		want:        3,
    31  		containment: free,
    32  
    33  		wantValues:    []float64{-2, -1, 0},
    34  		wantStep:      1,
    35  		wantMagnitude: 0,
    36  	},
    37  	{
    38  		dMin:        -1.9846500878911073,
    39  		dMax:        0.4370974820125605,
    40  		want:        3,
    41  		containment: containData,
    42  
    43  		wantValues:    []float64{-2, -1, 0, 1},
    44  		wantStep:      1,
    45  		wantMagnitude: 0,
    46  	},
    47  	{
    48  		dMin:        -1.985e-15,
    49  		dMax:        0.4371e-15,
    50  		want:        3,
    51  		containment: free,
    52  
    53  		wantValues:    []float64{-1.985e-15, -7.739500000000001e-16, 4.3709999999999994e-16},
    54  		wantStep:      1.21105e-15,
    55  		wantMagnitude: -16,
    56  	},
    57  	{
    58  		dMin:        -1.985e-15,
    59  		dMax:        0.4371e-15,
    60  		want:        3,
    61  		containment: containData,
    62  
    63  		wantValues:    []float64{-1.985e-15, -7.739500000000001e-16, 4.3709999999999994e-16},
    64  		wantStep:      1.21105e-15,
    65  		wantMagnitude: -16,
    66  	},
    67  	{
    68  		dMin:        -1.985e15,
    69  		dMax:        0.4371e15,
    70  		want:        3,
    71  		containment: free,
    72  
    73  		wantValues:    []float64{-2e+15, -1e+15, 0},
    74  		wantStep:      1,
    75  		wantMagnitude: 15,
    76  	},
    77  	{
    78  		dMin:        -1.985e15,
    79  		dMax:        0.4371e15,
    80  		want:        3,
    81  		containment: containData,
    82  
    83  		wantValues:    []float64{-2e+15, -1e+15, 0, 1e+15},
    84  		wantStep:      1,
    85  		wantMagnitude: 15,
    86  	},
    87  	{
    88  		dMin:        dlamchP * 20,
    89  		dMax:        dlamchP * 50,
    90  		want:        3,
    91  		containment: free,
    92  
    93  		wantValues:    []float64{4.440892098500626e-15, 7.771561172376096e-15, 1.1102230246251565e-14},
    94  		wantStep:      3.3306690738754696e-15,
    95  		wantMagnitude: -15,
    96  	},
    97  	{
    98  		dMin:        dlamchP * 20,
    99  		dMax:        dlamchP * 50,
   100  		want:        3,
   101  		containment: containData,
   102  
   103  		wantValues:    []float64{4.440892098500626e-15, 7.771561172376096e-15, 1.1102230246251565e-14},
   104  		wantStep:      3.3306690738754696e-15,
   105  		wantMagnitude: -15,
   106  	},
   107  	{
   108  		dMin:        math.MaxFloat64 / 4,
   109  		dMax:        math.MaxFloat64 / 3,
   110  		want:        3,
   111  		containment: free,
   112  
   113  		wantValues:    []float64{4.4942328371557893e+307, 5.243271643348421e+307, 5.992310449541053e+307},
   114  		wantStep:      7.490388061926317e+306,
   115  		wantMagnitude: 307,
   116  	},
   117  	{
   118  		dMin:        math.MaxFloat64 / 4,
   119  		dMax:        math.MaxFloat64 / 3,
   120  		want:        3,
   121  		containment: containData,
   122  
   123  		wantValues:    []float64{4.4942328371557893e+307, 5.243271643348421e+307, 5.992310449541053e+307},
   124  		wantStep:      7.490388061926317e+306,
   125  		wantMagnitude: 307,
   126  	},
   127  	{
   128  		dMin:        0.00010,
   129  		dMax:        0.00015,
   130  		want:        3,
   131  		containment: free,
   132  
   133  		wantValues:    []float64{0.0001, 0.000125, 0.00015000000000000001},
   134  		wantStep:      2.5,
   135  		wantMagnitude: -5,
   136  	},
   137  	{
   138  		dMin:        0.00010,
   139  		dMax:        0.00015,
   140  		want:        3,
   141  		containment: containData,
   142  
   143  		wantValues:    []float64{0.0001, 0.000125, 0.00015000000000000001},
   144  		wantStep:      2.5,
   145  		wantMagnitude: -5,
   146  	},
   147  	{
   148  		dMin:        555.6545,
   149  		dMax:        21800.9875,
   150  		want:        3,
   151  		containment: free,
   152  
   153  		wantValues:    []float64{0, 10000, 20000},
   154  		wantStep:      1,
   155  		wantMagnitude: 4,
   156  	},
   157  	{
   158  		dMin:        555.6545,
   159  		dMax:        21800.9875,
   160  		want:        3,
   161  		containment: containData,
   162  
   163  		wantValues:    []float64{0, 12000, 24000},
   164  		wantStep:      12,
   165  		wantMagnitude: 3,
   166  	},
   167  	{
   168  		dMin:        555.6545,
   169  		dMax:        27800.9875,
   170  		want:        3,
   171  		containment: free,
   172  
   173  		wantValues:    []float64{0, 10000, 20000, 30000},
   174  		wantStep:      1,
   175  		wantMagnitude: 4,
   176  	},
   177  	{
   178  		dMin:        555.6545,
   179  		dMax:        27800.9875,
   180  		want:        3,
   181  		containment: containData,
   182  
   183  		wantValues:    []float64{0, 10000, 20000, 30000},
   184  		wantStep:      1,
   185  		wantMagnitude: 4,
   186  	},
   187  	{
   188  		dMin:        55.6545,
   189  		dMax:        1555.9875,
   190  		want:        3,
   191  		containment: free,
   192  
   193  		wantValues:    []float64{0, 500, 1000, 1500},
   194  		wantStep:      5,
   195  		wantMagnitude: 2,
   196  	},
   197  	{
   198  		dMin:        55.6545,
   199  		dMax:        1555.9875,
   200  		want:        3,
   201  		containment: containData,
   202  
   203  		wantValues:    []float64{0, 800, 1600},
   204  		wantStep:      8,
   205  		wantMagnitude: 2,
   206  	},
   207  	{
   208  		dMin:        3.096916 - 0.125,
   209  		dMax:        3.096916 + 0.125,
   210  		want:        3,
   211  		containment: free,
   212  
   213  		wantValues:    []float64{3, 3.1, 3.2},
   214  		wantStep:      1,
   215  		wantMagnitude: -1,
   216  	},
   217  	{
   218  		dMin:        3.096916 - 0.125,
   219  		dMax:        3.096916 + 0.125,
   220  		want:        3,
   221  		containment: containData,
   222  
   223  		wantValues:    []float64{2.9499999999999997, 3.0999999999999996, 3.2499999999999996},
   224  		wantStep:      15,
   225  		wantMagnitude: -2,
   226  	},
   227  	// The following fails in the reference implementation with a
   228  	// warning of "probable complete loss of accuracy in modulus".
   229  	{
   230  		dMin:        99.99999999999996,
   231  		dMax:        100,
   232  		want:        3,
   233  		containment: free,
   234  
   235  		wantValues:    []float64{99.99999999999996, 99.99999999999997, 100},
   236  		wantStep:      2,
   237  		wantMagnitude: -14,
   238  	},
   239  }
   240  
   241  func TestTalbotLinHanrahan(t *testing.T) {
   242  	for _, test := range talbotLinHanrahanTests {
   243  		values, step, _, magnitude := talbotLinHanrahan(test.dMin, test.dMax, test.want, test.containment, nil, nil, nil)
   244  		if !reflect.DeepEqual(values, test.wantValues) {
   245  			t.Errorf("unexpected values for dMin=%g, dMax=%g, want=%d, containment=%d:\ngot: %v\nwant:%v",
   246  				test.dMin, test.dMax, test.want, test.containment, values, test.wantValues)
   247  		}
   248  		if step != test.wantStep {
   249  			t.Errorf("unexpected step for dMin=%g, dMax=%g, want=%d, containment=%d: got:%v want:%v",
   250  				test.dMin, test.dMax, test.want, test.containment, step, test.wantStep)
   251  		}
   252  		if magnitude != test.wantMagnitude {
   253  			t.Errorf("unexpected magnitude for dMin=%g, dMax=%g, want=%d, containment=%d: got:%d want:%d",
   254  				test.dMin, test.dMax, test.want, test.containment, magnitude, test.wantMagnitude)
   255  		}
   256  		if test.containment == containData {
   257  			f := math.Pow10(-magnitude)
   258  			if test.containment == containData && (test.dMin*f < values[0]*f || values[len(values)-1]*f < test.dMax*f) {
   259  				t.Errorf("unexpected values for containment dMin=%g, dMax=%g, want=%d not containment:\ngot: %v\nwant:%v",
   260  					test.dMin, test.dMax, test.want, values, test.wantValues)
   261  			}
   262  		}
   263  	}
   264  }