seed, teach, grow
d3a = require("d3-array@^2.2")
function join_aggregate(data_, opsOrd_, opsFunc_, aggKey_=d=>d["titre"]) {
// join aggregate
// - the data not aggregated yet
// opsOrd_ a set of opeartor "to refactor" check v7 prototype
// opsFunc function to apply to the aggreagated groups
// aggKey_ the main key to aggregate the data
function apply_join_function(data__, aggFld__, aggFun__, aggLbl__, aggKey__) {
// apply function on array of object
// my join aggregate implementation
// gpFld, sur leque appliquer la function d'aggrégation le champ d'aggrégation
let _data = Object.values(deep_copy(data__))
// convertis les date en str
// aggFun the function to compute on the arr of Obj
// funLbl the label for the result of aggFun
let _gp = d3a.group(_data, aggKey__);
let _vArr = [..._gp.values()], // arr of _gpObjs_
_kArr = [..._gp.keys()]; // arr of gpKey
let resArr = _vArr.map(
function(gpObjs___) {
return gpObjs___.map(
function(obj____, _, gpObjs____){
return Object.assign(obj____, ({[aggLbl__]: aggFun__(gpObjs____,aggFld__)}))
}
)
}
)
return resArr.flat()
}
// garder ts for numerique value and date for human formated value
return opsOrd_.reduce(
function(acc__, op__){
return apply_join_function(acc__, op__.field, opsFunc_[op__.op], op__.as, aggKey_)
},
data_)
}
function unstack(_map){
// unstack a map made with d3-array.group
return [..._map.values()].flat()
}
function is_empty(object) {
// test if an object is empty without creating an empty array
for(var i in object) {
return false;
}
return true;
}
function unzip(X, i){
let tmp = [];
for (let x of X){tmp.push(x[i]);}
return tmp;
}
function zip(s1, s2) {
// take 2 series of same lenght and return an array with the zip entries
let N = s2.length;
if (s2.length != N) {return "Not implemented yet!";}
let zipped = new Array(N);
for (let i=0; i<N; i++){
zipped[i] = [s1[i], s2[i]];
}
return zipped;
}
function deep_copy(obj, asArray=false){
// make a 'deep copy of an object'
let copy = Object.entries(obj).reduce((acc, [k, v]) => Object.assign(acc, ({[k]:v})), {});
return asArray? Object.values(copy): copy;
}
md`### Time utilities`
md`### SQL join like function`
function _hashInnerJoin(left, lkey, right, rkey){
// left join
// keep left obj only when keys match
return left.reduce(
function(ljoin, lobj){
// on récupère les objets de droit qui satisfont l'égalité de clefs
let robjs = right.filter(robj => robj[rkey] === lobj[lkey]);
// on construit le tableau des objet left right merged avec
// avec données à droite écransant les données à gauche
let objMerged = robjs.map(robj => ({...lobj, ...robj}));
// on ajoute les nouveaux objet à notre accumulateur
return ljoin.concat(objMerged)
},
new Array()
)
}
function _hashLeftOuterJoin(left, lkey, right, rkey){
// left outerjoin
// keep all left obj
// merge with right obAj if right is there
let joinArr;
joinArr = left.reduce(
function(lacc, lobj){
// on récupère les objets de droit qui satisfont l'égalité de clefs
let robjs = right.filter(robj => robj[rkey] === lobj[lkey]);
// on construit le tableau des objet left right merged avec
// avec données à droite écransant les données à gauche
// objMerged contient toujour lobj
//debugger;
let objMerged = robjs.length? robjs.map(robj => ({...lobj, ...robj})) : [lobj];
// on ajoute les nouveaux objet à notre accumulateur
return lacc.concat(objMerged)
//return lacc.concat([lobj])
},
new Array()
)
return joinArr;
}
//viewof params_form
Type JavaScript, then Shift-Enter. Ctrl-space for more options. Arrow ↑/↓ to switch modes.
/* **** Get params **** *//*
function get_rnd_var() {
// renvois la fonction aléatoire et ses paramètres.
// paramètres est un tableau à deux entrées avec soit bornes inf et sup soit mu et sigma
// debugger;
let nom_loi = params_form.loi;
let func;
if (nom_loi === "uniforme") {
return {func: d3.randomUniform,
func_name: nom_loi,
params : [params_form.binf, params_form.bsup]
}}
else {
// debugger;
switch(nom_loi) {
case 'normale':
func = d3.randomNormal;
break;
case 'lognormale':
func = d3.randomLogNormal;
break;
case 'bates':
func = d3.randomBates;
break;
case 'irwinhall':
func = d3.randomIrwinHall;
break;
case 'exponentielle':
func = d3.randomExponential;
break;
}
return {func: func,
func_name: nom_loi,
params: [params_form.mu, params_form.sigma]
};
}
}
*/
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
