1 require("../env");

     2 require("../../d3");

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

     7 var suite = vows.describe("d3.scale.sqrt");

     8 

     9 suite.addBatch({

    10   "sqrt": {

    11     topic: function() {

    12       return d3.scale.sqrt;

    13     },

    14 

    15     "domain": {

    16       "defaults to [0, 1]": function(sqrt) {

    17         var x = sqrt();

    18         assert.deepEqual(x.domain(), [0, 1]);

    19         assert.inDelta(x(.5), 0.7071068, 1e-6);

    20       },

    21       "coerces domain to numbers": function(sqrt) {

    22         var x = sqrt().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]);

    23         assert.equal(typeof x.domain()[0], "number");

    24         assert.equal(typeof x.domain()[1], "number");

    25         assert.inDelta(x(new Date(1989, 09, 20)), -.2, 1e-2);

    26         assert.inDelta(x(new Date(1990, 00, 01)), 0, 1e-2);

    27         assert.inDelta(x(new Date(1990, 02, 15)), .2, 1e-2);

    28         assert.inDelta(x(new Date(1990, 04, 27)), .4, 1e-2);

    29         assert.inDelta(x(new Date(1991, 00, 01)), 1, 1e-2);

    30         assert.inDelta(x(new Date(1991, 02, 15)), 1.2, 1e-2);

    31         var x = sqrt().domain(["0", "1"]);

    32         assert.equal(typeof x.domain()[0], "number");

    33         assert.equal(typeof x.domain()[1], "number");

    34         assert.inDelta(x(.5), 0.7071068, 1e-6);

    35         var x = sqrt().domain([new Number(0), new Number(1)]);

    36         assert.equal(typeof x.domain()[0], "number");

    37         assert.equal(typeof x.domain()[1], "number");

    38         assert.inDelta(x(.5), 0.7071068, 1e-6);

    39       },

    40       "can specify a polypower domain and range": function(sqrt) {

    41         var x = sqrt().domain([-10, 0, 100]).range(["red", "white", "green"]);

    42         assert.equal(x(-5), "#ff4b4b");

    43         assert.equal(x(50), "#4ba54b");

    44         assert.equal(x(75), "#229122");

    45       }

    46     },

    47 

    48     "range": {

    49       "defaults to [0, 1]": function(sqrt) {

    50         var x = sqrt();

    51         assert.deepEqual(x.range(), [0, 1]);

    52         assert.inDelta(x.invert(.5), .25, 1e-6);

    53       },

    54       "does not coerce range to numbers": function(sqrt) {

    55         var x = sqrt().range(["0", "2"]);

    56         assert.equal(typeof x.range()[0], "string");

    57         assert.equal(typeof x.range()[1], "string");

    58       },

    59       "coerces range value to number on invert": function(sqrt) {

    60         var x = sqrt().range(["0", "2"]);

    61         assert.inDelta(x.invert("1"), .25, 1e-6);

    62         var x = sqrt().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]);

    63         assert.inDelta(x.invert(new Date(1990, 6, 2, 13)), .25, 1e-6);

    64         var x = sqrt().range(["#000", "#fff"]);

    65         assert.isNaN(x.invert("#999"));

    66       },

    67       "can specify range values as colors": function(sqrt) {

    68         var x = sqrt().range(["red", "blue"]);

    69         assert.equal(x(.25), "#800080");

    70         var x = sqrt().range(["#ff0000", "#0000ff"]);

    71         assert.equal(x(.25), "#800080");

    72         var x = sqrt().range(["#f00", "#00f"]);

    73         assert.equal(x(.25), "#800080");

    74         var x = sqrt().range([d3.rgb(255,0,0), d3.hsl(240,1,.5)]);

    75         assert.equal(x(.25), "#800080");

    76         var x = sqrt().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"]);

    77         assert.equal(x(.25), "#800080");

    78       },

    79       "can specify range values as arrays or objects": function(sqrt) {

    80         var x = sqrt().range([{color: "red"}, {color: "blue"}]);

    81         assert.deepEqual(x(.25), {color: "#800080"});

    82         var x = sqrt().range([["red"], ["blue"]]);

    83         assert.deepEqual(x(.25), ["#800080"]);

    84       }

    85     },

    86 

    87     "exponent": {

    88       "defaults to .5": function(sqrt) {

    89         var x = sqrt();

    90         assert.equal(x.exponent(), .5);

    91       },

    92       "observes the specified exponent": function(sqrt) {

    93         var x = sqrt().exponent(.5).domain([1, 2]);

    94         assert.inDelta(x(1), 0, 1e-6);

    95         assert.inDelta(x(1.5), 0.5425821, 1e-6);

    96         assert.inDelta(x(2), 1, 1e-6);

    97         var x = sqrt().exponent(2).domain([1, 2]);

    98         assert.inDelta(x(1), 0, 1e-6);

    99         assert.inDelta(x(1.5), .41666667, 1e-6);

   100         assert.inDelta(x(2), 1, 1e-6);

   101         var x = sqrt().exponent(-1).domain([1, 2]);

   102         assert.inDelta(x(1), 0, 1e-6);

   103         assert.inDelta(x(1.5), .6666667, 1e-6);

   104         assert.inDelta(x(2), 1, 1e-6);

   105       },

   106       "changing the exponent does not change the domain or range": function(sqrt) {

   107         var x = sqrt().domain([1, 2]).range([3, 4]), f = d3.format(".6f");

   108         x.exponent(.5);

   109         assert.deepEqual(x.domain().map(f), [1, 2]);

   110         assert.deepEqual(x.range(), [3, 4]);

   111         x.exponent(2);

   112         assert.deepEqual(x.domain().map(f), [1, 2]);

   113         assert.deepEqual(x.range(), [3, 4]);

   114         x.exponent(-1);

   115         assert.deepEqual(x.domain().map(f), [1, 2]);

   116         assert.deepEqual(x.range(), [3, 4]);

   117       }

   118     },

   119 

   120     "interpolate": {

   121       "defaults to d3.interpolate": function(sqrt) {

   122         var x = sqrt().range(["red", "blue"]);

   123         assert.equal(x.interpolate(), d3.interpolate);

   124         assert.equal(x(.5), "#4b00b4");

   125       },

   126       "can specify a custom interpolator": function(sqrt) {

   127         var x = sqrt().range(["red", "blue"]).interpolate(d3.interpolateHsl);

   128         assert.equal(x(.25), "#00ff00");

   129       }

   130     },

   131 

   132     "clamp": {

   133       "defaults to false": function(sqrt) {

   134         var x = sqrt();

   135         assert.isFalse(x.clamp());

   136         assert.inDelta(x(-.5), -0.7071068, 1e-6);

   137         assert.inDelta(x(1.5), 1.22474487, 1e-6);

   138       },

   139       "can clamp to the domain": function(sqrt) {

   140         var x = sqrt().clamp(true);

   141         assert.inDelta(x(-.5), 0, 1e-6);

   142         assert.inDelta(x(.25), .5, 1e-6);

   143         assert.inDelta(x(1.5), 1, 1e-6);

   144         var x = sqrt().domain([1, 0]).clamp(true);

   145         assert.inDelta(x(-.5), 1, 1e-6);

   146         assert.inDelta(x(.25), .5, 1e-6);

   147         assert.inDelta(x(1.5), 0, 1e-6);

   148       }

   149     },

   150 

   151     "maps a number to a number": function(sqrt) {

   152       var x = sqrt().domain([1, 2]);

   153       assert.inDelta(x(.5), -0.7071068, 1e-6);

   154       assert.inDelta(x(1), 0, 1e-6);

   155       assert.inDelta(x(1.5), 0.5425821, 1e-6);

   156       assert.inDelta(x(2), 1, 1e-6);

   157       assert.inDelta(x(2.5), 1.4029932, 1e-6);

   158     },

   159 

   160     "ticks": {

   161       "can generate ticks of varying degree": function(sqrt) {

   162         var x = sqrt();

   163         assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);

   164         assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);

   165         assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);

   166         assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);

   167         var x = sqrt().domain([1, 0]);

   168         assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);

   169         assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);

   170         assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);

   171         assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);

   172       }

   173     },

   174 

   175     "nice": {

   176       "can nice the domain, extending it to round numbers": function(sqrt) {

   177         var x = sqrt().domain([1.1, 10.9]).nice(), f = d3.format(".6f");

   178         assert.deepEqual(x.domain().map(f), [1, 11]);

   179         var x = sqrt().domain([10.9, 1.1]).nice();

   180         assert.deepEqual(x.domain().map(f), [11, 1]);

   181         var x = sqrt().domain([.7, 11.001]).nice();

   182         assert.deepEqual(x.domain().map(f), [0, 12]);

   183         var x = sqrt().domain([123.1, 6.7]).nice();

   184         assert.deepEqual(x.domain().map(f), [130, 0]);

   185         var x = sqrt().domain([0, .49]).nice();

   186         assert.deepEqual(x.domain().map(f), [0, .5]);

   187       },

   188       "nicing a polypower domain only affects the extent": function(sqrt) {

   189         var x = sqrt().domain([1.1, 1, 2, 3, 10.9]).nice(), f = d3.format(".6f");

   190         assert.deepEqual(x.domain().map(f), [1, 1, 2, 3, 11]);

   191         var x = sqrt().domain([123.1, 1, 2, 3, -.9]).nice();

   192         assert.deepEqual(x.domain().map(f), [130, 1, 2, 3, "−10.000000"]);

   193       }

   194     },

   195 

   196     "copy": {

   197       "changes to the domain are isolated": function(sqrt) {

   198         var x = sqrt(), y = x.copy();

   199         x.domain([1, 2]);

   200         assert.deepEqual(y.domain(), [0, 1]);

   201         assert.equal(x(1), 0);

   202         assert.equal(y(1), 1);

   203         y.domain([2, 3]);

   204         assert.equal(x(2), 1);

   205         assert.equal(y(2), 0);

   206         assert.inDelta(x.domain(), [1, 2], 1e-6);

   207         assert.inDelta(y.domain(), [2, 3], 1e-6);

   208       },

   209       "changes to the range are isolated": function(sqrt) {

   210         var x = sqrt(), y = x.copy();

   211         x.range([1, 2]);

   212         assert.equal(x.invert(1), 0);

   213         assert.equal(y.invert(1), 1);

   214         assert.deepEqual(y.range(), [0, 1]);

   215         y.range([2, 3]);

   216         assert.equal(x.invert(2), 1);

   217         assert.equal(y.invert(2), 0);

   218         assert.deepEqual(x.range(), [1, 2]);

   219         assert.deepEqual(y.range(), [2, 3]);

   220       },

   221       "changes to the exponent are isolated": function(sqrt) {

   222         var x = sqrt().exponent(2), y = x.copy();

   223         x.exponent(.5);

   224         assert.inDelta(x(.5), Math.SQRT1_2, 1e-6);

   225         assert.inDelta(y(.5), 0.25, 1e-6);

   226         assert.equal(x.exponent(), .5);

   227         assert.equal(y.exponent(), 2);

   228         y.exponent(3);

   229         assert.inDelta(x(.5), Math.SQRT1_2, 1e-6);

   230         assert.inDelta(y(.5), 0.125, 1e-6);

   231         assert.equal(x.exponent(), .5);

   232         assert.equal(y.exponent(), 3);

   233       },

   234       "changes to the interpolator are isolated": function(sqrt) {

   235         var x = sqrt().range(["red", "blue"]), y = x.copy();

   236         x.interpolate(d3.interpolateHsl);

   237         assert.equal(x(0.5), "#00ffd3");

   238         assert.equal(y(0.5), "#4b00b4");

   239         assert.equal(y.interpolate(), d3.interpolate);

   240       },

   241       "changes to clamping are isolated": function(sqrt) {

   242         var x = sqrt().clamp(true), y = x.copy();

   243         x.clamp(false);

   244         assert.equal(x(2), Math.SQRT2);

   245         assert.equal(y(2), 1);

   246         assert.isTrue(y.clamp());

   247         y.clamp(false);

   248         assert.equal(x(2), Math.SQRT2);

   249         assert.equal(y(2), Math.SQRT2);

   250         assert.isFalse(x.clamp());

   251       }

   252     }

   253   }

   254 });

   255 

   256 suite.export(module);