diff --git a/libs/shared/lib/querybuilder/model/logic/mathAggregations.tsx b/libs/shared/lib/querybuilder/model/logic/mathAggregations.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..5baebb3b616deeca5186e454d524bc2f07fa6e3e
--- /dev/null
+++ b/libs/shared/lib/querybuilder/model/logic/mathAggregations.tsx
@@ -0,0 +1,745 @@
+/**
+ * This program has been developed by students from the bachelor Computer Science at
+ * Utrecht University within the Software Project course.
+ * © Copyright Utrecht University (Department of Information and Computing Sciences)
+ */
+
+import { Position } from 'reactflow';
+import { GeneralDescription, MathAggregationTypes } from './general';
+
+export const MathAggregations: Record<MathAggregationTypes, GeneralDescription<MathAggregationTypes>> = {
+ [MathAggregationTypes.AVG]: {
+ key: 'mathFunctionAvg',
+ name: 'Average',
+ type: MathAggregationTypes.AVG,
+ description: 'Average of all values',
+ numInputs: 1,
+ inputs: [{ name: '1', type: 'float', default: 0 }],
+ output: { name: 'avg', type: 'float' },
+ logic: ['Avg', '@1'],
+ },
+ [MathAggregationTypes.COUNT]: {
+ key: 'mathFunctionCount',
+ name: 'Count',
+ type: MathAggregationTypes.COUNT,
+ description: 'Count the number of values',
+ numInputs: 1,
+ inputs: [{ name: '1', type: 'float', default: 0 }],
+
+ output: { name: 'count', type: 'float' },
+ logic: ['Count', '@1'],
+ },
+ [MathAggregationTypes.MAX]: {
+ key: 'mathFunctionMax',
+ name: 'Maximum',
+ type: MathAggregationTypes.MAX,
+ description: 'Maximum of all values',
+ numInputs: 1,
+ inputs: [{ name: '1', type: 'float', default: 0 }],
+ output: { name: 'max', type: 'float' },
+ logic: ['Max', '@1'],
+ },
+ [MathAggregationTypes.MIN]: {
+ key: 'mathFunctionMin',
+ name: 'Minimum',
+ type: MathAggregationTypes.MIN,
+ description: 'Minimum of all values',
+ numInputs: 1,
+ inputs: [{ name: '1', type: 'float', default: 0 }],
+ output: { name: 'min', type: 'float' },
+ logic: ['Min', '@1'],
+ },
+ [MathAggregationTypes.SUM]: {
+ key: 'mathFunctionSum',
+ name: 'Sum',
+ type: MathAggregationTypes.SUM,
+ description: 'Sum of all values',
+ numInputs: 1,
+ inputs: [{ name: '1', type: 'float', default: 0 }],
+ output: { name: 'sum', type: 'float' },
+ logic: ['Sum', '@1'],
+ },
+ // [MathAggregationTypes.STD]: {
+ // key: 'mathFunctionStd',
+ // name: 'Standard Deviation',
+ // type: MathAggregationTypes.STD,
+ // description: 'Standard deviation of all values',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'std', type: 'float' },
+ // logic: ['Std', '@1'],
+ // },
+ // [MathAggregationTypes.ADD]: {
+ // key: 'mathFunctionAdd',
+ // name: 'Add',
+ // type: MathAggregationTypes.ADD,
+ // description: 'Add two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'float', default: 0 },
+ // { name: '2', type: 'float', default: 0 },
+ // ],
+ // output: { name: '+', type: 'float' },
+ // logic: ['+', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.SUBTRACT]: {
+ // key: 'mathFunctionSubtract',
+ // name: 'Subtract',
+ // type: MathAggregationTypes.SUBTRACT,
+ // description: 'Subtract two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'float' },
+ // { name: '2', type: 'float' },
+ // ],
+ // output: { name: '-', type: 'float' },
+ // logic: ['-', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.MULTIPLY]: {
+ // key: 'mathFunctionMultiply',
+ // name: 'Multiply',
+ // type: MathAggregationTypes.MULTIPLY,
+ // description: 'Multiply two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'float' },
+ // { name: '2', type: 'float' },
+ // ],
+ // output: { name: '*', type: 'float' },
+ // logic: ['*', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.DIVIDE]: {
+ // key: 'mathFunctionDivide',
+ // name: 'Divide',
+ // type: MathAggregationTypes.DIVIDE,
+ // description: 'Divide two values',
+
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'float' },
+ // { name: '2', type: 'float' },
+ // ],
+ // output: { name: '/', type: 'float' },
+ // logic: ['/', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.POWER]: {
+ // key: 'mathFunctionPower',
+ // name: 'Power',
+ // type: MathAggregationTypes.POWER,
+ // description: 'Raise a value to the power of another value',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'float' },
+ // { name: '2', type: 'float' },
+ // ],
+ // output: { name: '^', type: 'float' },
+ // logic: ['^', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.SQRT]: {
+ // key: 'mathFunctionSqrt',
+ // name: 'Square Root',
+ // type: MathAggregationTypes.SQRT,
+ // description: 'Square root of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'sqrt', type: 'float' },
+ // logic: ['Sqrt', '@1'],
+ // },
+ // [MathAggregationTypes.LOG]: {
+ // key: 'mathFunctionLog',
+ // name: 'Logarithm',
+ // type: MathAggregationTypes.LOG,
+ // description: 'Logarithm of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'log', type: 'float' },
+ // logic: ['Log', '@1'],
+ // },
+ // [MathAggregationTypes.EXP]: {
+ // key: 'mathFunctionExp',
+ // name: 'Exponential',
+ // type: MathAggregationTypes.EXP,
+ // description: 'Exponential of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'exp', type: 'float' },
+ // logic: ['Exp', '@1'],
+ // },
+ // [MathAggregationTypes.ABS]: {
+ // key: 'mathFunctionAbs',
+ // name: 'Absolute Value',
+ // type: MathAggregationTypes.ABS,
+ // description: 'Absolute value of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'abs', type: 'float' },
+ // logic: ['Abs', '@1'],
+ // },
+ // [MathAggregationTypes.CEIL]: {
+ // key: 'mathFunctionCeil',
+ // name: 'Ceiling',
+ // type: MathAggregationTypes.CEIL,
+ // description: 'Ceiling of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'ceil', type: 'float' },
+ // logic: ['Ceil', '@1'],
+ // },
+ // [MathAggregationTypes.FLOOR]: {
+ // key: 'mathFunctionFloor',
+ // name: 'Floor',
+ // type: MathAggregationTypes.FLOOR,
+ // description: 'Floor of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'floor', type: 'float' },
+ // logic: ['Floor', '@1'],
+ // },
+ // [MathAggregationTypes.ROUND]: {
+ // key: 'mathFunctionRound',
+ // name: 'Round',
+ // type: MathAggregationTypes.ROUND,
+ // description: 'Round a value to the nearest integer',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'round', type: 'float' },
+ // logic: ['Round', '@1'],
+ // },
+ // [MathAggregationTypes.TRUNC]: {
+ // key: 'mathFunctionTrunc',
+ // name: 'Truncate',
+ // type: MathAggregationTypes.TRUNC,
+ // description: 'Truncate a value to the nearest integer towards zero',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+
+ // output: { name: 'trunc', type: 'float' },
+ // logic: ['Trunc', '@1'],
+ // },
+ // [MathAggregationTypes.RANDOM]: {
+ // key: 'mathFunctionRandom',
+ // name: 'Random',
+ // type: MathAggregationTypes.RANDOM,
+ // description: 'Random value between 0 and 1',
+ // numInputs: 0,
+ // inputs: [],
+ // output: { name: 'random', type: 'float' },
+ // logic: ['Random'],
+ // },
+ // [MathAggregationTypes.RANDOMINT]: {
+ // key: 'mathFunctionRandomInt',
+ // name: 'Random Integer',
+ // type: MathAggregationTypes.RANDOMINT,
+ // description: 'Random integer between two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'min', type: 'float' },
+ // { name: 'max', type: 'float' },
+ // ],
+ // output: { name: 'randomInt', type: 'float' },
+ // logic: ['RandomInt', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.SIN]: {
+ // key: 'mathFunctionSin',
+ // name: 'Sine',
+ // type: MathAggregationTypes.SIN,
+ // description: 'Sine of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'sin', type: 'float' },
+ // logic: ['Sin', '@1'],
+ // },
+ // [MathAggregationTypes.COS]: {
+ // key: 'mathFunctionCos',
+ // name: 'Cosine',
+ // type: MathAggregationTypes.COS,
+ // description: 'Cosine of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'cos', type: 'float' },
+ // logic: ['Cos', '@1'],
+ // },
+ // [MathAggregationTypes.TAN]: {
+ // key: 'mathFunctionTan',
+ // name: 'Tangent',
+ // type: MathAggregationTypes.TAN,
+ // description: 'Tangent of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'tan', type: 'float' },
+ // logic: ['Tan', '@1'],
+ // },
+ // [MathAggregationTypes.ASIN]: {
+ // key: 'mathFunctionAsin',
+ // name: 'Arcsine',
+ // type: MathAggregationTypes.ASIN,
+ // description: 'Arcsine of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'asin', type: 'float' },
+ // logic: ['Asin', '@1'],
+ // },
+ // [MathAggregationTypes.ACOS]: {
+ // key: 'mathFunctionAcos',
+ // name: 'Arccosine',
+ // type: MathAggregationTypes.ACOS,
+ // description: 'Arccosine of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'acos', type: 'float' },
+ // logic: ['Acos', '@1'],
+ // },
+ // [MathAggregationTypes.ATAN]: {
+ // key: 'mathFunctionAtan',
+ // name: 'Arctangent',
+ // type: MathAggregationTypes.ATAN,
+ // description: 'Arctangent of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'atan', type: 'float' },
+ // logic: ['Atan', '@1'],
+ // },
+ // [MathAggregationTypes.SINH]: {
+ // key: 'mathFunctionSinh',
+ // name: 'Hyperbolic Sine',
+ // type: MathAggregationTypes.SINH,
+ // description: 'Hyperbolic sine of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'sinh', type: 'float' },
+ // logic: ['Sinh', '@1'],
+ // },
+ // [MathAggregationTypes.COSH]: {
+ // key: 'mathFunctionCosh',
+ // name: 'Hyperbolic Cosine',
+ // type: MathAggregationTypes.COSH,
+ // description: 'Hyperbolic cosine of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'cosh', type: 'float' },
+ // logic: ['Cosh', '@1'],
+ // },
+ // [MathAggregationTypes.TANH]: {
+ // key: 'mathFunctionTanh',
+ // name: 'Hyperbolic Tangent',
+ // type: MathAggregationTypes.TANH,
+ // description: 'Hyperbolic tangent of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'tanh', type: 'float' },
+ // logic: ['Tanh', '@1'],
+ // },
+ // [MathAggregationTypes.ASINH]: {
+ // key: 'mathFunctionAsinh',
+ // name: 'Hyperbolic Arcsine',
+ // type: MathAggregationTypes.ASINH,
+ // description: 'Hyperbolic arcsine of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'asinh', type: 'float' },
+ // logic: ['Asinh', '@1'],
+ // },
+ // [MathAggregationTypes.ACOSH]: {
+ // key: 'mathFunctionAcosh',
+ // name: 'Hyperbolic Arccosine',
+ // type: MathAggregationTypes.ACOSH,
+ // description: 'Hyperbolic arccosine of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'acosh', type: 'float' },
+ // logic: ['Acosh', '@1'],
+ // },
+ // [MathAggregationTypes.ATANH]: {
+ // key: 'mathFunctionAtanh',
+ // name: 'Hyperbolic Arctangent',
+ // type: MathAggregationTypes.ATANH,
+ // description: 'Hyperbolic arctangent of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'atanh', type: 'float' },
+ // logic: ['Atanh', '@1'],
+ // },
+ // [MathAggregationTypes.DEGREES]: {
+ // key: 'mathFunctionDegrees',
+ // name: 'Degrees',
+ // type: MathAggregationTypes.DEGREES,
+ // description: 'Convert a value from radians to degrees',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'degrees', type: 'float' },
+ // logic: ['Degrees', '@1'],
+ // },
+ // [MathAggregationTypes.RADIANS]: {
+ // key: 'mathFunctionRadians',
+ // name: 'Radians',
+ // type: MathAggregationTypes.RADIANS,
+ // description: 'Convert a value from degrees to radians',
+ // numInputs: 1,
+
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'radians', type: 'float' },
+ // logic: ['Radians', '@1'],
+ // },
+ // [MathAggregationTypes.SIGN]: {
+ // key: 'mathFunctionSign',
+ // name: 'Sign',
+ // type: MathAggregationTypes.SIGN,
+ // description: 'Sign of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'sign', type: 'float' },
+ // logic: ['Sign', '@1'],
+ // },
+ // [MathAggregationTypes.RANDOMNORMAL]: {
+ // key: 'mathFunctionRandomNormal',
+ // name: 'Random Normal',
+ // type: MathAggregationTypes.RANDOMNORMAL,
+ // description: 'Random value from a normal distribution',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'mean', type: 'float' },
+ // { name: 'std', type: 'float' },
+ // ],
+ // output: { name: 'randomNormal', type: 'float' },
+ // logic: ['RandomNormal', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.RANDOMLOGNORMAL]: {
+ // key: 'mathFunctionRandomLogNormal',
+ // name: 'Random Log Normal',
+ // type: MathAggregationTypes.RANDOMLOGNORMAL,
+ // description: 'Random value from a log normal distribution',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'mean', type: 'float' },
+ // { name: 'std', type: 'float' },
+ // ],
+ // output: { name: 'randomLogNormal', type: 'float' },
+ // logic: ['RandomLogNormal', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.RANDOMEXPONENTIAL]: {
+ // key: 'mathFunctionRandomExponential',
+ // name: 'Random Exponential',
+ // type: MathAggregationTypes.RANDOMEXPONENTIAL,
+ // description: 'Random value from an exponential distribution',
+ // numInputs: 1,
+ // inputs: [{ name: 'lambda', type: 'float' }],
+ // output: { name: 'randomExponential', type: 'float' },
+ // logic: ['RandomExponential', '@1'],
+ // },
+ // [MathAggregationTypes.RANDOMGAMMA]: {
+ // key: 'mathFunctionRandomGamma',
+ // name: 'Random Gamma',
+ // type: MathAggregationTypes.RANDOMGAMMA,
+ // description: 'Random value from a gamma distribution',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'alpha', type: 'float' },
+ // { name: 'beta', type: 'float' },
+ // ],
+ // output: { name: 'randomGamma', type: 'float' },
+ // logic: ['RandomGamma', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.RANDOMBETA]: {
+ // key: 'mathFunctionRandomBeta',
+ // name: 'Random Beta',
+ // type: MathAggregationTypes.RANDOMBETA,
+ // description: 'Random value from a beta distribution',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'alpha', type: 'float' },
+ // { name: 'beta', type: 'float' },
+ // ],
+ // output: { name: 'randomBeta', type: 'float' },
+ // logic: ['RandomBeta', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.RANDOMCHISQUARE]: {
+ // key: 'mathFunctionRandomChiSquare',
+ // name: 'Random Chi Square',
+ // type: MathAggregationTypes.RANDOMCHISQUARE,
+ // description: 'Random value from a chi square distribution',
+ // numInputs: 1,
+ // inputs: [{ name: 'k', type: 'float' }],
+ // output: { name: 'randomChiSquare', type: 'float' },
+ // logic: ['RandomChiSquare', '@1'],
+ // },
+ // [MathAggregationTypes.RANDOMWEIBULL]: {
+ // key: 'mathFunctionRandomWeibull',
+ // name: 'Random Weibull',
+ // type: MathAggregationTypes.RANDOMWEIBULL,
+ // description: 'Random value from a Weibull distribution',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'k', type: 'float' },
+ // { name: 'lambda', type: 'float' },
+ // ],
+ // output: { name: 'randomWeibull', type: 'float' },
+ // logic: ['RandomWeibull', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.RANDOMCAUCHY]: {
+ // key: 'mathFunctionRandomCauchy',
+ // name: 'Random Cauchy',
+ // type: MathAggregationTypes.RANDOMCAUCHY,
+ // description: 'Random value from a Cauchy distribution',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'x0', type: 'float' },
+ // { name: 'gamma', type: 'float' },
+ // ],
+ // output: { name: 'randomCauchy', type: 'float' },
+ // logic: ['RandomCauchy', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.RANDOMPOISSON]: {
+ // key: 'mathFunctionRandomPoisson',
+ // name: 'Random Poisson',
+ // type: MathAggregationTypes.RANDOMPOISSON,
+ // description: 'Random value from a Poisson distribution',
+ // numInputs: 1,
+ // inputs: [{ name: 'lambda', type: 'float' }],
+ // output: { name: 'randomPoisson', type: 'float' },
+ // logic: ['RandomPoisson', '@1'],
+ // },
+ // [MathAggregationTypes.RANDOMIRWINHALL]: {
+ // key: 'mathFunctionRandomIrwinHall',
+ // name: 'Random Irwin Hall',
+ // type: MathAggregationTypes.RANDOMIRWINHALL,
+ // description: 'Random value from an Irwin Hall distribution',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'n', type: 'float' },
+ // { name: 'scale', type: 'float' },
+ // ],
+ // output: { name: 'randomIrwinHall', type: 'float' },
+ // logic: ['RandomIrwinHall', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.CHIQUARETEST]: {
+ // key: 'mathFunctionChiSquareTest',
+ // name: 'Chi Square Test',
+ // type: MathAggregationTypes.CHIQUARETEST,
+ // description: 'Chi square test',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'observed', type: 'float' },
+ // { name: 'expected', type: 'float' },
+ // ],
+ // output: { name: 'chiSquareTest', type: 'float' },
+ // logic: ['ChiSquareTest', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.CORRELATION]: {
+ // key: 'mathFunctionCorrelation',
+ // name: 'Correlation',
+ // type: MathAggregationTypes.CORRELATION,
+ // description: 'Correlation between two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'float' },
+ // { name: '2', type: 'float' },
+ // ],
+ // output: { name: 'correlation', type: 'float' },
+ // logic: ['Correlation', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.COVARIANCE]: {
+ // key: 'mathFunctionCovariance',
+ // name: 'Covariance',
+ // type: MathAggregationTypes.COVARIANCE,
+ // description: 'Covariance between two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'float' },
+ // { name: '2', type: 'float' },
+ // ],
+ // output: { name: 'covariance', type: 'float' },
+ // logic: ['Covariance', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.FREQUENCY]: {
+ // key: 'mathFunctionFrequency',
+ // name: 'Frequency',
+ // type: MathAggregationTypes.FREQUENCY,
+ // description: 'Frequency of a value in a dataset',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'value', type: 'float' },
+ // { name: 'dataset', type: 'float' },
+ // ],
+ // output: { name: 'frequency', type: 'float' },
+ // logic: ['Frequency', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.MEAN]: {
+ // key: 'mathFunctionMean',
+ // name: 'Mean',
+ // type: MathAggregationTypes.MEAN,
+ // description: 'Mean of a dataset',
+ // numInputs: 1,
+ // inputs: [{ name: 'dataset', type: 'float' }],
+ // output: { name: 'mean', type: 'float' },
+ // logic: ['Mean', '@1'],
+ // },
+ // [MathAggregationTypes.MEDIAN]: {
+ // key: 'mathFunctionMedian',
+ // name: 'Median',
+ // type: MathAggregationTypes.MEDIAN,
+ // description: 'Median of a dataset',
+ // numInputs: 1,
+ // inputs: [{ name: 'dataset', type: 'float' }],
+ // output: { name: 'median', type: 'float' },
+ // logic: ['Median', '@1'],
+ // },
+ // [MathAggregationTypes.MODE]: {
+ // key: 'mathFunctionMode',
+ // name: 'Mode',
+ // type: MathAggregationTypes.MODE,
+ // description: 'Mode of a dataset',
+ // numInputs: 1,
+ // inputs: [{ name: 'dataset', type: 'float' }],
+ // output: { name: 'mode', type: 'float' },
+ // logic: ['Mode', '@1'],
+ // },
+ // [MathAggregationTypes.RANK]: {
+ // key: 'mathFunctionRank',
+ // name: 'Rank',
+ // type: MathAggregationTypes.RANK,
+ // description: 'Rank of a value in a dataset',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'value', type: 'float' },
+ // { name: 'dataset', type: 'float' },
+ // ],
+ // output: { name: 'rank', type: 'float' },
+ // logic: ['Rank', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.STDEV]: {
+ // key: 'mathFunctionStdev',
+ // name: 'Standard Deviation',
+ // type: MathAggregationTypes.STDEV,
+ // description: 'Standard deviation of a dataset',
+ // numInputs: 1,
+ // inputs: [{ name: 'dataset', type: 'float' }],
+ // output: { name: 'stdev', type: 'float' },
+ // logic: ['Stdev', '@1'],
+ // },
+ // [MathAggregationTypes.VARIANCE]: {
+ // key: 'mathFunctionVariance',
+ // name: 'Variance',
+ // type: MathAggregationTypes.VARIANCE,
+ // description: 'Variance of a dataset',
+ // numInputs: 1,
+ // inputs: [{ name: 'dataset', type: 'float' }],
+ // output: { name: 'variance', type: 'float' },
+ // logic: ['Variance', '@1'],
+ // },
+ // [MathAggregationTypes.ZSCORE]: {
+ // key: 'mathFunctionZscore',
+ // name: 'Z-Score',
+ // type: MathAggregationTypes.ZSCORE,
+ // description: 'Z-score of a value in a dataset',
+ // numInputs: 2,
+ // inputs: [
+ // { name: 'value', type: 'float' },
+ // { name: 'dataset', type: 'float' },
+ // ],
+ // output: { name: 'zscore', type: 'float' },
+ // logic: ['Zscore', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.AND]: {
+ // key: 'mathFunctionAnd',
+ // name: 'And',
+ // type: MathAggregationTypes.AND,
+ // description: 'Logical AND of two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'boolean' },
+ // { name: '2', type: 'boolean' },
+ // ],
+ // output: { name: 'and', type: 'boolean' },
+ // logic: ['And', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.OR]: {
+ // key: 'mathFunctionOr',
+ // name: 'Or',
+ // type: MathAggregationTypes.OR,
+ // description: 'Logical OR of two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'boolean' },
+ // { name: '2', type: 'boolean' },
+ // ],
+ // output: { name: 'or', type: 'boolean' },
+ // logic: ['Or', '@1', '@2'],
+ // },
+ // [MathAggregationTypes.NOT]: {
+ // key: 'mathFunctionNot',
+ // name: 'Not',
+ // type: MathAggregationTypes.NOT,
+ // description: 'Logical NOT of a value',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'boolean' }],
+ // output: { name: 'not', type: 'boolean' },
+ // logic: ['Not', '@1'],
+ // },
+
+ // {
+ // key: 'mathFunctionCount',
+ // name: 'Count',
+ // type: MathAggregationTypes.COUNT,
+ // description: 'Count the number of values',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'count', type: 'float' },
+ // logic: ['Count', '@1'],
+ // },
+ // {
+ // key: 'mathFunctionMax',
+ // name: 'Maximum',
+ // type: MathAggregationTypes.MAX,
+ // description: 'Maximum of all values',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'max', type: 'float' },
+ // logic: ['Max', '@1'],
+ // },
+ // {
+ // key: 'mathFunctionMin',
+ // name: 'Minimum',
+ // type: MathAggregationTypes.MIN,
+ // description: 'Minimum of all values',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'min', type: 'float' },
+ // logic: ['Min', '@1'],
+ // },
+ // {
+ // key: 'mathFunctionSum',
+ // name: 'Sum',
+ // type: MathAggregationTypes.SUM,
+ // description: 'Sum of all values',
+ // numInputs: 1,
+ // inputs: [{ name: '1', type: 'float' }],
+ // output: { name: 'sum', type: 'float' },
+ // logic: ['Sum', '@1'],
+ // },
+ // // {
+ // // key: 'mathFunctionStd',
+ // // name: 'Standard Deviation',
+ // // type: MathAggregationTypes.STD,
+ // // description: 'Standard deviation of all values',
+ // // numInputs: 1,
+ // // inputs: [{ name: '1', type: 'float' }],
+ // // output: { name: 'std', type: 'float' },
+ // // logic: ['Std', '@1'],
+ // // },
+ // {
+ // key: 'mathFunctionAdd',
+ // name: 'Add',
+ // type: MathAggregationTypes.ADD,
+ // description: 'Add two values',
+ // numInputs: 2,
+ // inputs: [
+ // { name: '1', type: 'float' },
+ // { name: '2', type: 'float' },
+ // ],
+ // output: { name: '+', type: 'float' },
+ // logic: ['+', '@1', '@2'],
+ // },
+};
+
+/** All available functions in the function bar. */
+export const MathAggregationArray: Array<GeneralDescription<MathAggregationTypes>> = Object.values(MathAggregations);
diff --git a/libs/shared/lib/querybuilder/model/logic/mathFilters.tsx b/libs/shared/lib/querybuilder/model/logic/mathFilters.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..0c235dd780eddf0da0e5f0f2f62d3ad494cd9396
--- /dev/null
+++ b/libs/shared/lib/querybuilder/model/logic/mathFilters.tsx
@@ -0,0 +1,93 @@
+/**
+ * This program has been developed by students from the bachelor Computer Science at
+ * Utrecht University within the Software Project course.
+ * © Copyright Utrecht University (Department of Information and Computing Sciences)
+ */
+
+import { Position } from 'reactflow';
+import { GeneralDescription, InputNode, MathFilterTypes } from './general';
+
+export const MathFilters: Record<MathFilterTypes, GeneralDescription<MathFilterTypes>> = {
+ [MathFilterTypes.EQUAL]: {
+ key: 'mathFilterEqual',
+ name: 'Equal',
+ type: MathFilterTypes.EQUAL,
+ description: 'Equal to another value',
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '==', type: 'float' },
+ logic: ['==', '@1', '@2'],
+ },
+ [MathFilterTypes.NOT_EQUAL]: {
+ key: 'mathFilterNotEqual',
+ name: 'Not Equal',
+ type: MathFilterTypes.NOT_EQUAL,
+ description: 'Not equal to another value',
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '!=', type: 'float' },
+ logic: ['!=', '@1', '@2'],
+ },
+ [MathFilterTypes.LESS_THAN]: {
+ key: 'mathFilterLessThan',
+ name: 'Less Than',
+ type: MathFilterTypes.LESS_THAN,
+ description: 'Less than another value',
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '<', type: 'float' },
+ logic: ['<', '@1', '@2'],
+ },
+ [MathFilterTypes.LESS_THAN_EQUAL]: {
+ key: 'mathFilterLessThanOrEqual',
+ name: 'Less Than or Equal',
+ type: MathFilterTypes.LESS_THAN_EQUAL,
+ description: 'Less than or equal to another value',
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '<=', type: 'float' },
+ logic: ['<=', '@1', '@2'],
+ },
+ [MathFilterTypes.GREATER_THAN]: {
+ key: 'mathFilterGreaterThan',
+ name: 'Greater Than',
+ type: MathFilterTypes.GREATER_THAN,
+ description: 'Greater than another value',
+
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '>', type: 'float' },
+ logic: ['>', '@1', '@2'],
+ },
+ [MathFilterTypes.GREATER_THAN_EQUAL]: {
+ key: 'mathFilterGreaterThanOrEqual',
+ name: 'Greater Than or Equal',
+ type: MathFilterTypes.GREATER_THAN_EQUAL,
+ description: 'Greater than or equal to another value',
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '>=', type: 'float' },
+ logic: ['>=', '@1', '@2'],
+ },
+};
+
+/** All available functions in the function bar. */
+export const MathFilterArray: Array<GeneralDescription<MathFilterTypes>> = Object.values(MathFilters);
diff --git a/libs/shared/lib/querybuilder/model/logic/mathFunctions.tsx b/libs/shared/lib/querybuilder/model/logic/mathFunctions.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..5375664aa5ef832c5ca60840f7e5c829d526c67f
--- /dev/null
+++ b/libs/shared/lib/querybuilder/model/logic/mathFunctions.tsx
@@ -0,0 +1,67 @@
+/**
+ * This program has been developed by students from the bachelor Computer Science at
+ * Utrecht University within the Software Project course.
+ * © Copyright Utrecht University (Department of Information and Computing Sciences)
+ */
+
+import { Position } from 'reactflow';
+import { GeneralDescription, MathFunctionTypes } from './general';
+
+export const MathFunctions: Record<MathFunctionTypes, GeneralDescription<MathFunctionTypes>> = {
+ [MathFunctionTypes.ADD]: {
+ key: 'mathFunctionAdd',
+ name: 'Add',
+ type: MathFunctionTypes.ADD,
+ description: 'Add two values',
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '+', type: 'float' },
+ logic: ['+', '@1', '@2'],
+ },
+ [MathFunctionTypes.SUBTRACT]: {
+ key: 'mathFunctionSubtract',
+ name: 'Subtract',
+ type: MathFunctionTypes.SUBTRACT,
+ description: 'Subtract two values',
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '-', type: 'float' },
+ logic: ['-', '@1', '@2'],
+ },
+ [MathFunctionTypes.MULTIPLY]: {
+ key: 'mathFunctionMultiply',
+ name: 'Multiply',
+ type: MathFunctionTypes.MULTIPLY,
+ description: 'Multiply two values',
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '*', type: 'float' },
+ logic: ['*', '@1', '@2'],
+ },
+ [MathFunctionTypes.DIVIDE]: {
+ key: 'mathFunctionDivide',
+ name: 'Divide',
+ type: MathFunctionTypes.DIVIDE,
+ description: 'Divide two values',
+
+ numInputs: 2,
+ inputs: [
+ { name: '1', type: 'float', default: 0 },
+ { name: '2', type: 'float', default: 0 },
+ ],
+ output: { name: '/', type: 'float' },
+ logic: ['/', '@1', '@2'],
+ },
+};
+
+/** All available functions in the function bar. */
+export const MathFunctionArray: Array<GeneralDescription<MathFunctionTypes>> = Object.values(MathFunctions);
diff --git a/libs/shared/lib/querybuilder/model/logic/utils.ts b/libs/shared/lib/querybuilder/model/logic/utils.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/libs/shared/node.d.ts b/libs/shared/node.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3d2ced5bc73ee7e961f830942deb2a6115058ed5
--- /dev/null
+++ b/libs/shared/node.d.ts
@@ -0,0 +1,13 @@
+interface ImportMeta {
+ env: {
+ VITE_BACKEND_URL: string;
+ VITE_BACKEND_WSS_URL: string;
+ VITE_BACKEND_USER: string;
+ VITE_BACKEND_SCHEMA: string;
+ VITE_BACKEND_QUERY: string;
+ VITE_STAGING: string;
+ VITE_KEYCLOAK_URL: string;
+ VITE_KEYCLOAK_REALM: string;
+ VITE_KEYCLOAK_CLIENT: string;
+ };
+}