Dates as dates

src/plots/cartesian/layout_attributes.js

@@ -137,34 +137,43 @@ module.exports = {
         ].join(' ')
     },
     tick0: {
-        valType: 'number',
+        valType: 'any',
         dflt: 0,
         role: 'style',
         description: [
             'Sets the placement of the first tick on this axis.',
             'Use with `dtick`.',
             'If the axis `type` is *log*, then you must take the log of your starting tick',
-            '(e.g. to set the starting tick to 100, set the `tick0` to 2).',
+            '(e.g. to set the starting tick to 100, set the `tick0` to 2)',
+            'except when `dtick`=*L<f>* (see `dtick` for more info).',
             'If the axis `type` is *date*, it should be a date string, like date data.',
             'If the axis `type` is *category*, it should be a number, using the scale where',
             'each category is assigned a serial number from zero in the order it appears.'
         ].join(' ')
     },
     dtick: {
         valType: 'any',
-        dflt: 1,
         role: 'style',
         description: [
-            'Sets the step in-between ticks on this axis',
-            'Use with `tick0`.',
+            'Sets the step in-between ticks on this axis. Use with `tick0`.',
+            'Must be a positive number, or special strings available to *log* and *date* axes.',
             'If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n',
             'is the tick number. For example,',
             'to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1.',
             'To set tick marks at 1, 100, 10000, ... set dtick to 2.',
             'To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433.',
+            '*log* has several special values; *L<f>*, where `f` is a positive number,',
+            'gives ticks linearly spaced in value (but not position).',
+            'For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc.',
+            'To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5).',
+            '`tick0` is ignored for *D1* and *D2*.',
             'If the axis `type` is *date*, then you must convert the time to milliseconds.',
             'For example, to set the interval between ticks to one day,',
-            'set `dtick` to 86400000.0.'
+            'set `dtick` to 86400000.0.',
+            '*date* also has special values *M<n>* gives ticks spaced by a number of months.',
+            '`n` must be a positive integer.',
+            'To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*.',
+            'To set ticks every 4 years, set `dtick` to *M48*'
         ].join(' ')
     },
     tickvals: {

src/plots/cartesian/tick_value_defaults.js

@@ -22,22 +22,53 @@ module.exports = function handleTickValueDefaults(containerIn, containerOut, coe
     }
 
     if(Array.isArray(containerIn.tickvals)) tickmodeDefault = 'array';
-    else if(containerIn.dtick && isNumeric(containerIn.dtick)) {
+    else if(containerIn.dtick) {
         tickmodeDefault = 'linear';
     }
     var tickmode = coerce('tickmode', tickmodeDefault);
 
     if(tickmode === 'auto') coerce('nticks');
     else if(tickmode === 'linear') {
-        var tick0 = coerce('tick0');
-        coerce('dtick');
+        // dtick is usually a positive number, but there are some
+        // special strings available for log or date axes
+        // default is 1 day for dates, otherwise 1
+        var dtickDflt = (axType === 'date') ? 86400000 : 1;
+        var dtick = coerce('dtick', dtickDflt);
+        if(isNumeric(dtick)) {
+            containerOut.dtick = (dtick > 0) ? Number(dtick) : dtickDflt;
+        }
+        else if(typeof dtick !== 'string') {
+            containerOut.dtick = dtickDflt;
+        }
+        else {
+            // date and log special cases are all one character plus a number
+            var prefix = dtick.charAt(0),
+                dtickNum = dtick.substr(1);
+
+            dtickNum = isNumeric(dtickNum) ? Number(dtickNum) : 0;
+            if((dtickNum <= 0) || !(
+                    // "M<n>" gives ticks every (integer) n months
+                    (axType === 'date' && prefix === 'M' && dtickNum === Math.round(dtickNum)) ||
+                    // "L<f>" gives ticks linearly spaced in data (not in position) every (float) f
+                    (axType === 'log' && prefix === 'L') ||
+                    // "D1" gives powers of 10 with all small digits between, "D2" gives only 2 and 5
+                    (axType === 'log' && prefix === 'D' && (dtickNum === 1 || dtickNum === 2))
+                )) {
+                containerOut.dtick = dtickDflt;
+            }
+        }
 
         // tick0 can have different valType for different axis types, so
         // validate that now. Also for dates, change milliseconds to date strings
+        var tick0 = coerce('tick0');
         if(axType === 'date') {
             containerOut.tick0 = Lib.cleanDate(tick0, '2000-01-01');
         }
-        else if(!isNumeric(tick0)) {
+        // Aside from date axes, dtick must be numeric; D1 and D2 modes ignore tick0 entirely
+        else if(isNumeric(tick0) && dtick !== 'D1' && dtick !== 'D2') {
+            containerOut.tick0 = Number(tick0);
+        }
+        else {
             containerOut.tick0 = 0;
         }
     }

test/jasmine/tests/axes_test.js

@@ -676,6 +676,85 @@ describe('Test axes', function() {
             expect(axOut.dtick).toBe(0.00159);
         });
 
+        it('should handle tick0 and dtick for date axes', function() {
+            var someMs = 123456789,
+                someMsDate = Lib.ms2DateTime(someMs),
+                oneDay = 24 * 3600 * 1000,
+                axIn = {tick0: someMs, dtick: String(3 * oneDay)},
+                axOut = {};
+            mockSupplyDefaults(axIn, axOut, 'date');
+            expect(axOut.tick0).toBe(someMsDate);
+            expect(axOut.dtick).toBe(3 * oneDay);
+
+            var someDate = '2011-12-15 13:45:56';
+            axIn = {tick0: someDate, dtick: 'M15'};
+            axOut = {};
+            mockSupplyDefaults(axIn, axOut, 'date');
+            expect(axOut.tick0).toBe(someDate);
+            expect(axOut.dtick).toBe('M15');
+
+            // now some stuff that shouldn't work, should give defaults
+            [
+                ['next thursday', -1],
+                ['123-45', 'L1'],
+                ['', 'M0.5'],
+                ['', 'M-1'],
+                ['', '2000-01-01']
+            ].forEach(function(v) {
+                axIn = {tick0: v[0], dtick: v[1]};
+                axOut = {};
+                mockSupplyDefaults(axIn, axOut, 'date');
+                expect(axOut.tick0).toBe('2000-01-01');
+                expect(axOut.dtick).toBe(oneDay);
+            });
+        });
+
+        it('should handle tick0 and dtick for log axes', function() {
+            var axIn = {tick0: '0.2', dtick: 0.3},
+                axOut = {};
+            mockSupplyDefaults(axIn, axOut, 'log');
+            expect(axOut.tick0).toBe(0.2);
+            expect(axOut.dtick).toBe(0.3);
+
+            ['D1', 'D2'].forEach(function(v) {
+                axIn = {tick0: -1, dtick: v};
+                axOut = {};
+                mockSupplyDefaults(axIn, axOut, 'log');
+                // tick0 gets ignored for D<n>
+                expect(axOut.tick0).toBe(0);
+                expect(axOut.dtick).toBe(v);
+            });
+
+            [
+                [-1, 'L3'],
+                ['0.2', 'L0.3'],
+                [-1, 3],
+                ['0.1234', '0.69238473']
+            ].forEach(function(v) {
+                axIn = {tick0: v[0], dtick: v[1]};
+                axOut = {};
+                mockSupplyDefaults(axIn, axOut, 'log');
+                expect(axOut.tick0).toBe(Number(v[0]));
+                expect(axOut.dtick).toBe((+v[1]) ? Number(v[1]) : v[1]);
+            });
+
+            // now some stuff that should not work, should give defaults
+            [
+                ['', -1],
+                ['D1', 'D3'],
+                ['', 'D0'],
+                ['2011-01-01', 'L0'],
+                ['', 'L-1']
+            ].forEach(function(v) {
+                axIn = {tick0: v[0], dtick: v[1]};
+                axOut = {};
+                mockSupplyDefaults(axIn, axOut, 'log');
+                expect(axOut.tick0).toBe(0);
+                expect(axOut.dtick).toBe(1);
+            });
+
+        });
+
         it('should set tickvals and ticktext iff tickmode=array', function() {
             var axIn = {tickmode: 'auto', tickvals: [1, 2, 3], ticktext: ['4', '5', '6']},
                 axOut = {};