improviseGradientFromShorter(shortColors: Color[], numColors: number): Color[] {
        const newColors = clone(shortColors)

        while (newColors.length < numColors) {
            for (let i = newColors.length - 1; i > 0; i -= 1) {
                const startColor = rgb(newColors[i - 1])
                const endColor = rgb(newColors[i])
                const newColor = interpolate(startColor, endColor)(0.5)
                newColors.splice(i, 0, newColor)

                if (newColors.length >= numColors) break
            }
        }

        return newColors
    }

function interpolateArray(scaleArr: string[]) {
    const N = scaleArr.length - 2 // -1 for spacings, -1 for number of interpolate fns
    const intervalWidth = 1 / N
    const intervals: Array<(t: number) => string> = []

    for (let i = 0; i <= N; i++) {
        intervals[i] = interpolate(rgb(scaleArr[i]), rgb(scaleArr[i + 1]))
    }

    return (t: number) => {
        if (t < 0 || t > 1) throw new Error('Outside the allowed range of [0, 1]')

        const i = Math.floor(t * N)
        const intervalOffset = i * intervalWidth

        return intervals[i](t / intervalWidth - intervalOffset / intervalWidth)
    }
}

export function invertColor(value: string): string {
  const color = d3_color.rgb(value);
  const { r, g, b, opacity } = color;
  if (opacity === 0) {
    return color.toString();
  }
  const yiq = ((r * 299) + (g * 587) + (b * 114)) / 1000;
  const depth = (yiq >= 128) ? -.8 : .8;

  return shadeRGBColor(color, depth);
}

export function rgb2hex(color) {
  color = rgb(color).toString();
  color = color.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
  color =
    color && color.length === 4
      ? '#' +
        ('0' + parseInt(color[1], 10).toString(16)).slice(-2) +
        ('0' + parseInt(color[2], 10).toString(16)).slice(-2) +
        ('0' + parseInt(color[3], 10).toString(16)).slice(-2)
      : '';
  return color.toUpperCase();
}

let num: number,
    str: string,
    arrNum: number[],
    arrStr: string[],
    objKeyVal: { [key: string]: any },
    objRGBColor: d3Color.RGBColor,
    objHSVColor: d3Hsv.HSVColor,
    zoom: [number, number, number];

// test interpolate(a, b) signature ----------------------------------------------------

iNum = d3Interpolate.interpolate('1', 5);


// color interpolator returning a color string
iString = d3Interpolate.interpolate('seagreen', d3Color.rgb(100, 100, 100));
iString = d3Interpolate.interpolate('seagreen', d3Hsv.hsv(60, 1, 0.2, 0.4));
iString = d3Interpolate.interpolate('seagreen', 'steelblue'); // as used with valid color name string

// date interpolator
iDate = d3Interpolate.interpolate(new Date(2016, 6, 1), new Date(2016, 6, 31));

// regular string interpolator interpolating number strings (as the strings are not valid color strings)
iString = d3Interpolate.interpolate(1, '5');
iString = d3Interpolate.interpolate('a: 1', 'a: 5');
iString = d3Interpolate.interpolate(new StringCoercible('a: 1'), 'a: 5');

iArrayNum = d3Interpolate.interpolate(['1', '2'], [4, 8]);
iArrayStr = d3Interpolate.interpolate(['1', '2'], ['4', '8']);
// two element array with first element date and second element string
iArrayMixed = d3Interpolate.interpolate<[Date, string]>([new Date(2016, 6, 1), 'b: 2'], [new Date(2016, 6, 31), 'b: 8']);

import * as d3Color from 'd3-color';

// Signature tests for 'color', rgb and hsl

let c: d3Color.RGBColor | d3Color.HSLColor | null;
let cRGB: d3Color.RGBColor;
let cHSL: d3Color.HSLColor;
let displayable: boolean;
let cString: string;
let nil: null;

c = d3Color.color('oops');
c = d3Color.color('steelblue');
c = d3Color.color('rgba(20, 100, 200, 0.5)');
c = d3Color.color(d3Color.rgb(0, 0, 0));

cRGB = d3Color.color('hsl(60, 100%, 20%, 0.5)')!.rgb();

cRGB = d3Color.rgb(20, 100, 200);
cRGB = d3Color.rgb(20, 100, 200, 0.5);
cRGB = d3Color.rgb('steelblue');
cRGB = d3Color.rgb('rgba(20, 100, 200, 0.5)');
cRGB = d3Color.rgb(c);
cRGB = cRGB.brighter();
cRGB = cRGB.brighter(0.2);
cRGB = cRGB.darker();
cRGB = cRGB.darker(0.2);
cRGB = cRGB.rgb();
displayable = cRGB.displayable();
cString = cRGB.toString();

 private calculateColor(d: TrialNodeData, trial_id: number): any {
   var proportion = Math.round(255 * (1.0 - (d.duration[trial_id] / this.maxTotalDuration)));
   //Math.round(510 * (node.duration - self.min_duration[node.trial_id]) / self.total_duration[node.trial_id]);
   return d3_rgb(255, proportion, proportion, 255).toString();
 }

// Specifier signature

cHSV = hsv('rgb(255, 255, 255)');
cHSV = hsv('rgb(10%, 20%, 30%)');
cHSV = hsv('rgba(255, 255, 255, 0.4)');
cHSV = hsv('rgba(10%, 20%, 30%, 0.4)');
cHSV = hsv('hsl(120, 50%, 20%)');
cHSV = hsv('hsla(120, 50%, 20%, 0.4)');
cHSV = hsv('#ffeeaa');
cHSV = hsv('#fea');
cHSV = hsv('steelblue');
cHSV = hsv('');

// Color signature

cRGB = rgb('steelblue');
cHSV = hsv(cRGB);
cHSV = hsv(cHSV);

// Method signatures

cHSV = cHSV.brighter();
cHSV = cHSV.brighter(0.2);
cHSV = cHSV.darker();
cHSV = cHSV.darker(0.2);
displayable = cHSV.displayable();
cString = cHSV.toString();
console.log('Channels = (h : %d, s: %d, v: %d)', cHSV.h, cHSV.s, cHSV.v);
console.log('Opacity = %d', cHSV.opacity);

// Interpolater

// hsv signature
cHSV = hsv(120, 0.4, 0.5);
cHSV = hsv(120, 0.4, 0.5, 0.5);

// specifier signature
cHSV = hsv('rgb(255, 255, 255)');
cHSV = hsv('rgb(10%, 20%, 30%)');
cHSV = hsv('rgba(255, 255, 255, 0.4)');
cHSV = hsv('rgba(10%, 20%, 30%, 0.4)');
cHSV = hsv('hsl(120, 50%, 20%)');
cHSV = hsv('hsla(120, 50%, 20%, 0.4)');
cHSV = hsv('#ffeeaa');
cHSV = hsv('#fea');
cHSV = hsv('steelblue');

// color signature
c = rgb('steelblue');
cHSV = hsv(c);
cHSV = hsv(cHSV);

// method signatures
cHSV = cHSV.brighter();
cHSV = cHSV.brighter(0.2);
cHSV = cHSV.darker();
cHSV = cHSV.darker(0.2);
displayable = cHSV.displayable();
cString = cHSV.toString();
console.log('Channels = (h : %d, s: %d, v: %d)', cHSV.h, cHSV.s, cHSV.v);
console.log('Opacity = %d', cHSV.opacity);

export function hexToRgb(value: string): any {
  // deprecated, use d3.color()
  return d3_color.rgb(value);
}