Scale values

Scale input and output values for use in discrete algorithms

by Scott Kaye

JavaScript

const arrayify = value => {
  return Array.isArray(value) ? value : [value];
};

const unarrayify = values => {
	return values.length === 1 ? values[0] : values;
};

const scale = values => {  
	let map = new Map();
  for (let [i, entry] of values.entries()) {
    map.set(arrayify(entry.input), arrayify(entry.output));
  }
  
  let flatInputs = [].concat.apply([], [...map.keys()]);
  let flatOutputs = [].concat.apply([], [...map.values()]);
  
  let maxes = [flatInputs, flatOutputs].map(arr => Math.max(...arr));
  
  // Scale values in map
  map.clear();
  for (let [i, entry] of values.entries()) {
  	let input = arrayify(entry.input).map(v => v / maxes[0]);
    let output = arrayify(entry.output).map(v => v / maxes[1]);
  	map.set(input, output);
  }
  
  let scaled = [...map.keys()].map(key => ({
  	input: key,
    output: unarrayify(map.get(key))
  }));
  
  return {
  	values: scaled,
    maxes: {
    	input: maxes[0],
      output: maxes[1]
    }
  };
};

const unscale = (values, maxes) => {
	if (!maxes) {
    maxes = values.maxes;
  	values = values.values;
  }

	let unscaled = [];
  for (let [i, entry] of values.entries()) {
    unscaled.push({
    	input: arrayify(entry.input).map(v => v *= maxes.input),
      output: unarrayify(arrayify(entry.output).map(v => v *= maxes.output))
    });
  }
  
  return unscaled;
};

console.clear();
let vals = [{
	"input": [4, 7],
  "output": 10
}, {
	"input": [7, 10],
  "output": 17
}];

let scaled = scale(vals);
let unscaled = unscale(scaled);

console.log(scaled, unscaled);