diff --git a/resources/public/android-chrome-192x192.png b/resources/public/android-chrome-192x192.png
new file mode 100644
index 00000000..9a0959dd
Binary files /dev/null and b/resources/public/android-chrome-192x192.png differ
diff --git a/resources/public/android-chrome-512x512.png b/resources/public/android-chrome-512x512.png
new file mode 100644
index 00000000..823d4417
Binary files /dev/null and b/resources/public/android-chrome-512x512.png differ
diff --git a/resources/public/apple-touch-icon.png b/resources/public/apple-touch-icon.png
new file mode 100644
index 00000000..76e1b4d9
Binary files /dev/null and b/resources/public/apple-touch-icon.png differ
diff --git a/resources/public/favicon-16x16.png b/resources/public/favicon-16x16.png
new file mode 100644
index 00000000..7264d73b
Binary files /dev/null and b/resources/public/favicon-16x16.png differ
diff --git a/resources/public/favicon-32x32.png b/resources/public/favicon-32x32.png
new file mode 100644
index 00000000..e54f1592
Binary files /dev/null and b/resources/public/favicon-32x32.png differ
diff --git a/resources/public/favicon.ico b/resources/public/favicon.ico
new file mode 100644
index 00000000..1d60f596
Binary files /dev/null and b/resources/public/favicon.ico differ
diff --git a/resources/public/js/solver-charts.js b/resources/public/js/solver-charts.js
new file mode 100644
index 00000000..ca9d798f
--- /dev/null
+++ b/resources/public/js/solver-charts.js
@@ -0,0 +1,793 @@
+/**
+ * Chart-related functions for the solver
+ */
+
+// Chart instances
+let fitChart = null;
+let dataEditorChart = null;
+let editorData = [];
+let historyCharts = {};
+let scoreCharts = {};
+
+// Brush state
+let currentBrushMode = 'point';
+let brushSize = 3;
+let brushDragging = false;
+let brushStartY = null;
+
+// Set brush mode and update UI
+function setBrushMode(mode) {
+ currentBrushMode = mode;
+
+ // Update button styles
+ document.querySelectorAll('.brush-mode-btn').forEach(btn => {
+ btn.classList.remove('bg-blue-600', 'text-white');
+ btn.classList.add('text-gray-300');
+ });
+ const activeBtn = document.getElementById(`brush-${mode}`);
+ if (activeBtn) {
+ activeBtn.classList.remove('text-gray-300');
+ activeBtn.classList.add('bg-blue-600', 'text-white');
+ }
+
+ // Show/hide brush size control
+ const sizeContainer = document.getElementById('brush-size-container');
+ if (sizeContainer) {
+ sizeContainer.classList.toggle('hidden', mode === 'point');
+ }
+
+ // Update hint text
+ const hint = document.getElementById('brush-hint');
+ if (hint) {
+ const hints = {
+ 'point': '(drag points to adjust Y values)',
+ 'smooth': '(click and drag to smooth nearby points)',
+ 'bump': '(drag up/down to raise/lower nearby points)',
+ 'flatten': '(click and drag to flatten nearby points)'
+ };
+ hint.textContent = hints[mode] || '';
+ }
+
+ // Reinitialize handlers for the new mode
+ if (dataEditorChart && editorData.length > 0) {
+ setupDragHandlers();
+ }
+}
+
+// Update brush size
+function updateBrushSize(value) {
+ brushSize = parseInt(value);
+ const sizeValue = document.getElementById('brush-size-value');
+ if (sizeValue) {
+ sizeValue.textContent = value;
+ }
+}
+
+// Initialize the data editor chart
+function initDataEditorChart() {
+ const container = document.getElementById('data-editor-chart');
+ if (!container) return;
+
+ // Dispose existing chart to ensure clean state
+ if (dataEditorChart) {
+ dataEditorChart.dispose();
+ dataEditorChart = null;
+ }
+
+ dataEditorChart = echarts.init(container, 'dark');
+ dataEditorChart.setOption({ animation: false });
+
+ const xs = document.getElementById('xs').value.split(',').map(s => parseFloat(s.trim())).filter(n => !isNaN(n));
+ const ys = document.getElementById('ys').value.split(',').map(s => parseFloat(s.trim())).filter(n => !isNaN(n));
+
+ if (xs.length === 0 || ys.length === 0) {
+ dataEditorChart.clear();
+ return;
+ }
+
+ editorData = xs.map((x, i) => ({ x, y: ys[i] !== undefined ? ys[i] : 0, index: i }));
+ updateDataEditorChart();
+}
+
+// Calculate symbol size based on number of points
+function getEditorSymbolSize(numPoints) {
+ if (numPoints <= 10) return 12;
+ if (numPoints <= 25) return 10;
+ if (numPoints <= 50) return 8;
+ if (numPoints <= 100) return 6;
+ return 4;
+}
+
+// Update the data editor chart display
+function updateDataEditorChart() {
+ if (!dataEditorChart || editorData.length === 0) return;
+
+ const symbolSize = getEditorSymbolSize(editorData.length);
+
+ const option = {
+ backgroundColor: 'transparent',
+ grid: { left: '12%', right: '5%', top: '10%', bottom: '15%' },
+ xAxis: {
+ type: 'value',
+ axisLine: { lineStyle: { color: '#4b5563' } },
+ axisLabel: { color: '#9ca3af', fontSize: 10 },
+ splitLine: { lineStyle: { color: '#374151' } }
+ },
+ yAxis: {
+ type: 'value',
+ axisLine: { lineStyle: { color: '#4b5563' } },
+ axisLabel: { color: '#9ca3af', fontSize: 10 },
+ splitLine: { lineStyle: { color: '#374151' } }
+ },
+ series: [{
+ type: 'scatter',
+ symbolSize: symbolSize,
+ data: editorData.map(d => [d.x, d.y]),
+ itemStyle: { color: '#3b82f6' },
+ cursor: 'ns-resize'
+ }]
+ };
+
+ dataEditorChart.setOption(option);
+ setupDragHandlers();
+}
+
+// Get indices of points within brush radius of a given index
+function getPointsInBrushRadius(centerIdx) {
+ const indices = [];
+ for (let i = Math.max(0, centerIdx - brushSize); i <= Math.min(editorData.length - 1, centerIdx + brushSize); i++) {
+ indices.push(i);
+ }
+ return indices;
+}
+
+// Calculate Gaussian weight for distance from center
+function gaussianWeight(distance, sigma) {
+ return Math.exp(-(distance * distance) / (2 * sigma * sigma));
+}
+
+// Apply smooth brush: weighted average with neighbors
+function applySmooth(centerIdx) {
+ const indices = getPointsInBrushRadius(centerIdx);
+ if (indices.length < 2) return;
+
+ const sigma = brushSize / 2;
+
+ // Calculate smoothed values for affected points
+ indices.forEach(idx => {
+ let weightedSum = 0;
+ let weightSum = 0;
+
+ indices.forEach(neighborIdx => {
+ const distance = Math.abs(neighborIdx - idx);
+ const weight = gaussianWeight(distance, sigma);
+ weightedSum += editorData[neighborIdx].y * weight;
+ weightSum += weight;
+ });
+
+ // Blend original with smoothed (strength based on proximity to brush center)
+ const centerDistance = Math.abs(idx - centerIdx);
+ const blendFactor = gaussianWeight(centerDistance, sigma) * 0.5;
+ const smoothedY = weightedSum / weightSum;
+ editorData[idx].y = editorData[idx].y * (1 - blendFactor) + smoothedY * blendFactor;
+ });
+}
+
+// Apply bump brush: raise or lower points based on delta Y
+function applyBump(centerIdx, deltaY) {
+ const indices = getPointsInBrushRadius(centerIdx);
+ const sigma = brushSize / 2;
+
+ indices.forEach(idx => {
+ const distance = Math.abs(idx - centerIdx);
+ const weight = gaussianWeight(distance, sigma);
+ editorData[idx].y += deltaY * weight * 0.3; // Scale factor for smoother control
+ });
+}
+
+// Apply flatten brush: move points toward their local average
+function applyFlatten(centerIdx) {
+ const indices = getPointsInBrushRadius(centerIdx);
+ if (indices.length < 2) return;
+
+ // Calculate local average
+ const avg = indices.reduce((sum, idx) => sum + editorData[idx].y, 0) / indices.length;
+ const sigma = brushSize / 2;
+
+ // Move points toward average
+ indices.forEach(idx => {
+ const distance = Math.abs(idx - centerIdx);
+ const weight = gaussianWeight(distance, sigma) * 0.3; // Blend factor
+ editorData[idx].y = editorData[idx].y * (1 - weight) + avg * weight;
+ });
+}
+
+// Find nearest data point index to a pixel position
+function findNearestPointIndex(pixelX) {
+ if (!dataEditorChart || editorData.length === 0) return -1;
+
+ let nearestIdx = 0;
+ let nearestDist = Infinity;
+
+ try {
+ editorData.forEach((d, idx) => {
+ const pointPixel = dataEditorChart.convertToPixel('grid', [d.x, d.y]);
+ if (pointPixel) {
+ const dist = Math.abs(pointPixel[0] - pixelX);
+ if (dist < nearestDist) {
+ nearestDist = dist;
+ nearestIdx = idx;
+ }
+ }
+ });
+ } catch (e) {
+ return -1;
+ }
+
+ return nearestIdx;
+}
+
+// Refresh the chart display
+function refreshEditorChart() {
+ if (!dataEditorChart) return;
+ try {
+ dataEditorChart.setOption({
+ series: [{ data: editorData.map(d => [d.x, d.y]) }]
+ }, false);
+ } catch (e) {
+ console.warn('refreshEditorChart error:', e);
+ }
+}
+
+// Store brush handler references so we can remove them specifically
+let brushMousedownHandler = null;
+let brushMousemoveHandler = null;
+let brushMouseupHandler = null;
+let brushGlobaloutHandler = null;
+
+// Remove only our custom brush handlers (not all handlers)
+function removeBrushHandlers() {
+ if (!dataEditorChart) return;
+ const zr = dataEditorChart.getZr();
+ if (brushMousedownHandler) {
+ zr.off('mousedown', brushMousedownHandler);
+ brushMousedownHandler = null;
+ }
+ if (brushMousemoveHandler) {
+ zr.off('mousemove', brushMousemoveHandler);
+ brushMousemoveHandler = null;
+ }
+ if (brushMouseupHandler) {
+ zr.off('mouseup', brushMouseupHandler);
+ brushMouseupHandler = null;
+ }
+ if (brushGlobaloutHandler) {
+ zr.off('globalout', brushGlobaloutHandler);
+ brushGlobaloutHandler = null;
+ }
+}
+
+// Set up drag handlers for points
+function setupDragHandlers() {
+ if (!dataEditorChart || editorData.length === 0) return;
+
+ // Remove only our custom brush handlers (preserve ECharts internal handlers)
+ removeBrushHandlers();
+
+ const container = document.getElementById('data-editor-chart');
+
+ if (currentBrushMode === 'point') {
+ // Reset cursor for point mode
+ if (container) {
+ container.style.cursor = 'default';
+ }
+
+ // Point mode: handle dragging via zrender events (more reliable than graphic draggable)
+ const zr = dataEditorChart.getZr();
+ let draggingIdx = -1;
+ let lastY = null;
+
+ brushMousedownHandler = function(e) {
+ const nearestIdx = findNearestPointIndex(e.offsetX);
+ if (nearestIdx < 0) return;
+
+ // Check if click is close enough to a point (within ~20 pixels)
+ const pointPixel = dataEditorChart.convertToPixel('grid', [editorData[nearestIdx].x, editorData[nearestIdx].y]);
+ const dist = Math.sqrt(Math.pow(e.offsetX - pointPixel[0], 2) + Math.pow(e.offsetY - pointPixel[1], 2));
+ if (dist > 20) return;
+
+ draggingIdx = nearestIdx;
+ lastY = e.offsetY;
+ };
+
+ brushMousemoveHandler = function(e) {
+ if (draggingIdx < 0) return;
+
+ // Convert pixel Y to data Y
+ const dataPos = dataEditorChart.convertFromPixel('grid', [0, e.offsetY]);
+ editorData[draggingIdx].y = dataPos[1];
+ lastY = e.offsetY;
+
+ // Update chart
+ dataEditorChart.setOption({
+ series: [{ data: editorData.map(d => [d.x, d.y]) }]
+ });
+ };
+
+ brushMouseupHandler = function(e) {
+ if (draggingIdx >= 0) {
+ draggingIdx = -1;
+ syncEditorToTextarea();
+ }
+ };
+
+ brushGlobaloutHandler = function(e) {
+ if (draggingIdx >= 0) {
+ draggingIdx = -1;
+ syncEditorToTextarea();
+ }
+ };
+
+ zr.on('mousedown', brushMousedownHandler);
+ zr.on('mousemove', brushMousemoveHandler);
+ zr.on('mouseup', brushMouseupHandler);
+ zr.on('globalout', brushGlobaloutHandler);
+ } else {
+ // Brush modes: use zrender mouse events on the chart area
+
+ // Set cursor for brush modes
+ if (container) {
+ container.style.cursor = currentBrushMode === 'bump' ? 'ns-resize' : 'crosshair';
+ }
+
+ const zr = dataEditorChart.getZr();
+ let lastY = null;
+ let lastIdx = null;
+
+ // Define handlers as named functions so we can remove them specifically
+ brushMousedownHandler = function(e) {
+ // Check if click is within the grid area
+ try {
+ const gridModel = dataEditorChart.getModel().getComponent('grid');
+ if (gridModel && gridModel.coordinateSystem) {
+ const gridRect = gridModel.coordinateSystem.getRect();
+ if (e.offsetX < gridRect.x || e.offsetX > gridRect.x + gridRect.width ||
+ e.offsetY < gridRect.y || e.offsetY > gridRect.y + gridRect.height) {
+ return;
+ }
+ }
+ } catch (err) {
+ // If we can't get the grid rect, proceed anyway
+ }
+
+ brushDragging = true;
+ brushStartY = e.offsetY;
+ lastY = e.offsetY;
+
+ const nearestIdx = findNearestPointIndex(e.offsetX);
+ lastIdx = nearestIdx;
+
+ if (nearestIdx >= 0) {
+ if (currentBrushMode === 'smooth') {
+ applySmooth(nearestIdx);
+ refreshEditorChart();
+ } else if (currentBrushMode === 'flatten') {
+ applyFlatten(nearestIdx);
+ refreshEditorChart();
+ }
+ }
+ };
+
+ brushMousemoveHandler = function(e) {
+ if (!brushDragging) return;
+
+ const nearestIdx = findNearestPointIndex(e.offsetX);
+ if (nearestIdx < 0) return;
+
+ if (currentBrushMode === 'bump') {
+ if (Math.abs(e.offsetY - lastY) > 1) {
+ // Convert pixel delta to data delta (invert because screen Y is opposite to data Y)
+ const dataCenter = dataEditorChart.convertFromPixel('grid', [0, lastY]);
+ const dataNew = dataEditorChart.convertFromPixel('grid', [0, e.offsetY]);
+ const dataDelta = dataNew[1] - dataCenter[1];
+ applyBump(nearestIdx, dataDelta);
+ lastY = e.offsetY;
+ refreshEditorChart();
+ }
+ } else if (currentBrushMode === 'smooth') {
+ if (nearestIdx !== lastIdx) {
+ applySmooth(nearestIdx);
+ lastIdx = nearestIdx;
+ refreshEditorChart();
+ }
+ } else if (currentBrushMode === 'flatten') {
+ if (nearestIdx !== lastIdx) {
+ applyFlatten(nearestIdx);
+ lastIdx = nearestIdx;
+ refreshEditorChart();
+ }
+ }
+ };
+
+ brushMouseupHandler = function(e) {
+ if (brushDragging) {
+ brushDragging = false;
+ syncEditorToTextarea();
+ }
+ };
+
+ brushGlobaloutHandler = function(e) {
+ if (brushDragging) {
+ brushDragging = false;
+ syncEditorToTextarea();
+ }
+ };
+
+ // Register the handlers
+ zr.on('mousedown', brushMousedownHandler);
+ zr.on('mousemove', brushMousemoveHandler);
+ zr.on('mouseup', brushMouseupHandler);
+ zr.on('globalout', brushGlobaloutHandler);
+ }
+}
+
+// Update drag handler positions - no longer needed since we use zrender events
+// Kept for compatibility but does nothing now
+function updateDragHandlerPositions() {
+ // No-op: we no longer use graphic elements for point dragging
+}
+
+// Sync editor data to Y values textarea
+// skipClearDatasetName: set to true when syncing for form submission (data wasn't manually edited)
+function syncEditorToTextarea(skipClearDatasetName = false) {
+ const ys = editorData.map(d => d.y.toFixed(6));
+ document.getElementById('ys').value = ys.join(', ');
+ // Clear dataset name only if user manually edited via drag (not during form submission sync)
+ if (!skipClearDatasetName) {
+ clearDatasetName();
+ }
+}
+
+// Initialize or update the fit chart
+// Optional customXs/customYs parameters for multi-job support
+function renderFitChart(formula, animate = true, customXs = null, customYs = null) {
+ const chartContainer = document.getElementById('fit-chart');
+ if (!chartContainer) return;
+
+ if (!fitChart) {
+ fitChart = echarts.init(chartContainer, 'dark');
+ }
+
+ // Use custom xs/ys if provided, otherwise fall back to global inputXs/inputYs
+ const xs = customXs || inputXs;
+ const ys = customYs || inputYs;
+
+ const dataPoints = xs.map((x, i) => ({ x: x, y: ys[i] }));
+ dataPoints.sort((a, b) => a.x - b.x);
+ const sortedXs = dataPoints.map(p => p.x);
+ const sortedYs = dataPoints.map(p => p.y);
+
+ const mathJsFormula = convertFormula(formula);
+
+ try {
+ const node = math.parse(mathJsFormula);
+ const compiled = node.compile();
+
+ const dataXMin = Math.min(...sortedXs);
+ const dataXMax = Math.max(...sortedXs);
+ const range = dataXMax - dataXMin;
+ const extension = range * 0.15;
+ const xMin = dataXMin - extension;
+ const xMax = dataXMax + extension;
+ const step = (xMax - xMin) / 100;
+ const curveXs = [];
+ const curveYs = [];
+
+ // Calculate y-axis bounds from objective data with padding
+ const dataYMin = Math.min(...sortedYs);
+ const dataYMax = Math.max(...sortedYs);
+ const yRange = dataYMax - dataYMin;
+ const yPadding = Math.max(yRange * 0.5, Math.abs(dataYMax) * 0.1, Math.abs(dataYMin) * 0.1, 1);
+ const yAxisMin = Math.floor(dataYMin - yPadding);
+ const yAxisMax = Math.ceil(dataYMax + yPadding);
+
+ // Clipping bounds with small margin so line visibly exits the chart
+ const clipMax = yAxisMax + yPadding * 0.1;
+ const clipMin = yAxisMin - yPadding * 0.1;
+
+ for (let x = xMin; x <= xMax; x += step) {
+ curveXs.push(x);
+ try {
+ const y = compiled.evaluate({ x: x });
+ // Clip curve values to axis bounds
+ if (!isFinite(y)) {
+ curveYs.push(null);
+ } else if (y > clipMax) {
+ curveYs.push(clipMax);
+ } else if (y < clipMin) {
+ curveYs.push(clipMin);
+ } else {
+ curveYs.push(y);
+ }
+ } catch (e) {
+ curveYs.push(null);
+ }
+ }
+
+ const option = {
+ animation: animate,
+ backgroundColor: 'transparent',
+ tooltip: {
+ trigger: 'axis',
+ backgroundColor: '#1f2937',
+ borderColor: '#374151',
+ textStyle: { color: '#f3f4f6' }
+ },
+ legend: {
+ data: ['Objective Data', 'Best Function'],
+ textStyle: { color: '#9ca3af' },
+ top: 10
+ },
+ grid: { left: '3%', right: '4%', bottom: '3%', containLabel: true },
+ xAxis: {
+ type: 'value',
+ name: 'x',
+ nameTextStyle: { color: '#9ca3af' },
+ axisLine: { lineStyle: { color: '#4b5563' } },
+ axisLabel: { color: '#9ca3af' },
+ splitLine: { lineStyle: { color: '#374151' } }
+ },
+ yAxis: {
+ type: 'value',
+ name: 'y',
+ nameTextStyle: { color: '#9ca3af' },
+ axisLine: { lineStyle: { color: '#4b5563' } },
+ axisLabel: { color: '#9ca3af' },
+ splitLine: { lineStyle: { color: '#374151' } },
+ min: yAxisMin,
+ max: yAxisMax
+ },
+ series: [
+ {
+ name: 'Objective Data',
+ type: 'scatter',
+ symbol: 'circle',
+ symbolSize: 8,
+ data: sortedXs.map((x, i) => [x, sortedYs[i]]),
+ itemStyle: { color: '#3b82f6' }
+ },
+ {
+ name: 'Best Function',
+ type: 'line',
+ smooth: true,
+ showSymbol: false,
+ data: curveXs.map((x, i) => [x, curveYs[i]]),
+ lineStyle: { color: '#22c55e', width: 2 },
+ itemStyle: { color: '#22c55e' }
+ }
+ ]
+ };
+
+ fitChart.setOption(option);
+ } catch (e) {
+ console.error('Error evaluating formula:', e);
+ chartContainer.innerHTML = 'Could not evaluate formula for charting
';
+ fitChart = null;
+ }
+}
+
+// Render chart for a history item
+function renderHistoryChart(index) {
+ const job = jobHistory[index];
+ const container = document.getElementById(`history-chart-${index}`);
+ if (!container || !job) return;
+
+ if (historyCharts[index]) {
+ historyCharts[index].dispose();
+ }
+
+ const chart = echarts.init(container, 'dark');
+ historyCharts[index] = chart;
+
+ const dataPoints = job.xs.map((x, i) => ({ x, y: job.ys[i] }));
+ dataPoints.sort((a, b) => a.x - b.x);
+ const sortedXs = dataPoints.map(p => p.x);
+ const sortedYs = dataPoints.map(p => p.y);
+
+ // Calculate y-axis bounds from objective data with padding
+ const dataYMin = Math.min(...sortedYs);
+ const dataYMax = Math.max(...sortedYs);
+ const yRange = dataYMax - dataYMin;
+ const yPadding = Math.max(yRange * 0.5, Math.abs(dataYMax) * 0.1, Math.abs(dataYMin) * 0.1, 1);
+ const yAxisMin = Math.floor(dataYMin - yPadding);
+ const yAxisMax = Math.ceil(dataYMax + yPadding);
+
+ // Clipping bounds with small margin so line visibly exits the chart
+ const clipMax = yAxisMax + yPadding * 0.1;
+ const clipMin = yAxisMin - yPadding * 0.1;
+
+ const mathJsFormula = convertFormula(job.formula);
+ let curveXs = [], curveYs = [];
+ try {
+ const node = math.parse(mathJsFormula);
+ const compiled = node.compile();
+ const xMin = Math.min(...sortedXs);
+ const xMax = Math.max(...sortedXs);
+ const range = xMax - xMin;
+ const step = range / 50;
+ for (let x = xMin - range * 0.1; x <= xMax + range * 0.1; x += step) {
+ curveXs.push(x);
+ try {
+ const y = compiled.evaluate({ x });
+ // Clip curve values to axis bounds
+ if (!isFinite(y)) {
+ curveYs.push(null);
+ } else if (y > clipMax) {
+ curveYs.push(clipMax);
+ } else if (y < clipMin) {
+ curveYs.push(clipMin);
+ } else {
+ curveYs.push(y);
+ }
+ } catch (e) { curveYs.push(null); }
+ }
+ } catch (e) { console.error('Chart error:', e); }
+
+ chart.setOption({
+ animation: false,
+ backgroundColor: 'transparent',
+ grid: { left: '10%', right: '5%', top: '10%', bottom: '15%' },
+ xAxis: { type: 'value', axisLine: { lineStyle: { color: '#4b5563' } }, axisLabel: { color: '#9ca3af', fontSize: 10 }, splitLine: { lineStyle: { color: '#374151' } } },
+ yAxis: { type: 'value', min: yAxisMin, max: yAxisMax, axisLine: { lineStyle: { color: '#4b5563' } }, axisLabel: { color: '#9ca3af', fontSize: 10 }, splitLine: { lineStyle: { color: '#374151' } } },
+ series: [
+ { type: 'scatter', symbolSize: 6, data: sortedXs.map((x, i) => [x, sortedYs[i]]), itemStyle: { color: '#3b82f6' } },
+ { type: 'line', smooth: true, showSymbol: false, data: curveXs.map((x, i) => [x, curveYs[i]]), lineStyle: { color: '#22c55e', width: 2 } }
+ ]
+ });
+}
+
+// Dispose fit chart
+function disposeFitChart() {
+ if (fitChart) {
+ fitChart.dispose();
+ fitChart = null;
+ }
+}
+
+// Render a compact score progression chart (logarithmic Y-axis)
+function renderScoreChart(containerId, scoreHistory, chartKey = null) {
+ const container = document.getElementById(containerId);
+ if (!container || !scoreHistory || scoreHistory.length === 0) {
+ if (container) container.innerHTML = 'Waiting for data...
';
+ return;
+ }
+
+ // Need at least 2 points to draw a line
+ if (scoreHistory.length < 2) {
+ container.innerHTML = 'Collecting data...
';
+ return;
+ }
+
+ // Dispose existing chart if using a keyed chart
+ const key = chartKey || containerId;
+ if (scoreCharts[key]) {
+ scoreCharts[key].dispose();
+ }
+
+ const chart = echarts.init(container, 'dark');
+ scoreCharts[key] = chart;
+
+ // Prepare data - scores should decrease (better), so we show them going down
+ const data = scoreHistory.map(h => [h.iteration, h.score]);
+
+ // Calculate if log scale is appropriate (scores span more than 2 orders of magnitude)
+ const scores = scoreHistory.map(h => h.score).filter(s => s > 0);
+ const minScore = Math.min(...scores);
+ const maxScore = Math.max(...scores);
+ const useLogScale = maxScore / minScore > 100;
+
+ // Add some padding to Y range
+ const yPadding = (maxScore - minScore) * 0.1 || maxScore * 0.1;
+
+ const option = {
+ animation: false,
+ backgroundColor: 'transparent',
+ grid: {
+ left: 50,
+ right: 10,
+ top: 10,
+ bottom: 25
+ },
+ tooltip: {
+ trigger: 'axis',
+ backgroundColor: '#1f2937',
+ borderColor: '#374151',
+ textStyle: { color: '#f3f4f6', fontSize: 11 },
+ formatter: function(params) {
+ const p = params[0];
+ return `Iter ${p.data[0]}: ${p.data[1].toExponential(2)}`;
+ }
+ },
+ xAxis: {
+ type: 'value',
+ name: 'iter',
+ nameLocation: 'middle',
+ nameGap: 12,
+ nameTextStyle: { color: '#6b7280', fontSize: 10 },
+ axisLine: { lineStyle: { color: '#374151' } },
+ axisLabel: { color: '#6b7280', fontSize: 9 },
+ splitLine: { show: false },
+ min: 0
+ },
+ yAxis: {
+ type: 'value',
+ name: '',
+ axisLine: { lineStyle: { color: '#374151' } },
+ axisLabel: {
+ color: '#6b7280',
+ fontSize: 9,
+ formatter: function(val) {
+ if (Math.abs(val) >= 1000000) return val.toExponential(0);
+ if (Math.abs(val) >= 1000) return (val/1000).toFixed(0) + 'k';
+ if (Math.abs(val) >= 1) return val.toFixed(0);
+ if (Math.abs(val) >= 0.01) return val.toFixed(2);
+ return val.toExponential(0);
+ }
+ },
+ splitLine: { lineStyle: { color: '#374151', opacity: 0.5 } },
+ min: Math.max(0, minScore - yPadding),
+ max: maxScore + yPadding
+ },
+ series: [{
+ type: 'line',
+ smooth: true,
+ showSymbol: scoreHistory.length < 20,
+ symbolSize: 2,
+ data: data,
+ lineStyle: { color: '#f59e0b', width: 1 },
+ itemStyle: { color: '#f59e0b' },
+ areaStyle: {
+ color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
+ { offset: 0, color: 'rgba(245, 158, 11, 0.3)' },
+ { offset: 1, color: 'rgba(245, 158, 11, 0.05)' }
+ ])
+ }
+ }]
+ };
+
+ chart.setOption(option);
+}
+
+// Dispose a score chart by key
+function disposeScoreChart(key) {
+ if (scoreCharts[key]) {
+ scoreCharts[key].dispose();
+ delete scoreCharts[key];
+ }
+}
+
+// Generate inline SVG sparkline for a specific scoring method from score history
+function generateMethodSparkline(scoreHistory, methodKey, width = 80, height = 20) {
+ if (!scoreHistory || scoreHistory.length < 2) return '';
+
+ // Extract scores for this method
+ const scores = scoreHistory
+ .map(h => h[methodKey])
+ .filter(s => s !== undefined && s !== null && isFinite(s));
+
+ if (scores.length < 2) return '';
+
+ const minScore = Math.min(...scores);
+ const maxScore = Math.max(...scores);
+ const range = maxScore - minScore || 1;
+
+ const points = scores.map((score, i) => {
+ const x = (i / (scores.length - 1)) * width;
+ const y = height - ((score - minScore) / range) * (height - 2) - 1;
+ return `${x.toFixed(1)},${y.toFixed(1)}`;
+ }).join(' ');
+
+ return ``;
+}
diff --git a/resources/public/js/solver-formula.js b/resources/public/js/solver-formula.js
new file mode 100644
index 00000000..e2e8f2b1
--- /dev/null
+++ b/resources/public/js/solver-formula.js
@@ -0,0 +1,146 @@
+/**
+ * Formula conversion and LaTeX rendering
+ */
+
+// Convert formula from symbolic regression format to math.js format
+function convertFormula(formula) {
+ let converted = formula
+ .replace(/Log\(/g, 'log(')
+ .replace(/Exp\(/g, 'exp(')
+ .replace(/Sqrt\(/g, 'sqrt(')
+ .replace(/Abs\(/g, 'abs(')
+ .replace(/Asin\(/g, 'asin(')
+ .replace(/ArcSin\(/g, 'asin(')
+ .replace(/Acos\(/g, 'acos(')
+ .replace(/ArcCos\(/g, 'acos(')
+ .replace(/Atan\(/g, 'atan(')
+ .replace(/ArcTan\(/g, 'atan(')
+ .replace(/Sinh\(/g, 'sinh(')
+ .replace(/Cosh\(/g, 'cosh(')
+ .replace(/Tanh\(/g, 'tanh(')
+ .replace(/Sec\(/g, 'sec(')
+ .replace(/Csc\(/g, 'csc(')
+ .replace(/Cot\(/g, 'cot(')
+ .replace(/Sin\(/g, 'sin(')
+ .replace(/Cos\(/g, 'cos(')
+ .replace(/Tan\(/g, 'tan(')
+ .replace(/\bPi\b/g, 'pi')
+ .replace(/\bE\b/g, 'e');
+ return converted;
+}
+
+// Add line breaks to long LaTeX formulas
+function wrapLatexWithLineBreaks(latex, termsPerLine = 2, maxLineLength = 5) {
+ let depth = 0;
+ let termCount = 0;
+ let lineLength = 0;
+ let result = '';
+ let i = 0;
+
+ function addLineBreak() {
+ result += ' \\\\ ';
+ termCount = 0;
+ lineLength = 0;
+ }
+
+ while (i < latex.length) {
+ const char = latex[i];
+
+ if (char === '{' || char === '(' || char === '[') {
+ depth++;
+ result += char;
+ lineLength++;
+ i++;
+ } else if (char === '}' || char === ')' || char === ']') {
+ depth--;
+ result += char;
+ lineLength++;
+ i++;
+ } else if (latex.slice(i, i + 5) === '\\left') {
+ depth++;
+ result += '\\left';
+ lineLength += 5;
+ i += 5;
+ } else if (latex.slice(i, i + 6) === '\\right') {
+ depth--;
+ result += '\\right';
+ lineLength += 6;
+ i += 6;
+ } else if (depth === 0 && (char === '+' || (char === '-' && i > 0))) {
+ termCount++;
+ if (termCount >= termsPerLine || lineLength >= maxLineLength) {
+ addLineBreak();
+ }
+ result += char;
+ lineLength++;
+ i++;
+ } else {
+ result += char;
+ lineLength++;
+ i++;
+ }
+ }
+
+ if (result.includes('\\\\')) {
+ return '\\begin{aligned} ' + result + ' \\end{aligned}';
+ }
+ return result;
+}
+
+// Copy LaTeX source to clipboard
+function copyLatex(elementId) {
+ const el = document.getElementById(elementId);
+ if (!el || !el.dataset.latex) return;
+ navigator.clipboard.writeText(el.dataset.latex).then(() => {
+ // Brief visual feedback
+ const btn = el.querySelector('.latex-copy-btn');
+ if (btn) {
+ btn.classList.add('text-white');
+ setTimeout(() => btn.classList.remove('text-white'), 200);
+ }
+ });
+}
+
+// Render LaTeX formula to an element using math.js toTex()
+function renderLatex(elementId, formula) {
+ const element = document.getElementById(elementId);
+ if (!element) return;
+ try {
+ const mathJsFormula = convertFormula(formula);
+ const node = math.parse(mathJsFormula);
+ let latex = node.toTex();
+ const wrappedLatex = wrapLatexWithLineBreaks(latex);
+
+ // Store raw LaTeX source for copying
+ element.dataset.latex = latex;
+
+ // Create flex wrapper with scrollable latex and fixed copy button
+ element.innerHTML = '';
+ element.classList.add('group', 'flex', 'items-start', 'gap-2');
+ element.classList.remove('overflow-x-auto'); // Remove from parent, add to child
+
+ // Scrollable latex container
+ const latexContainer = document.createElement('div');
+ latexContainer.className = 'flex-1 min-w-0 overflow-x-auto';
+ katex.render(wrappedLatex, latexContainer, {
+ throwOnError: false,
+ displayMode: true
+ });
+ element.appendChild(latexContainer);
+
+ // Fixed copy button (outside scrollable area)
+ const copyBtn = document.createElement('button');
+ copyBtn.className = 'latex-copy-btn flex-shrink-0 p-1 opacity-0 group-hover:opacity-100 transition-opacity text-gray-400 hover:text-white bg-gray-800 rounded';
+ copyBtn.title = 'Copy LaTeX source';
+ copyBtn.onclick = () => copyLatex(elementId);
+ copyBtn.innerHTML = `
+
+ `;
+ element.appendChild(copyBtn);
+ } catch (e) {
+ console.error('LaTeX render error:', e);
+ element.textContent = formula;
+ }
+}
diff --git a/resources/public/js/solver-history.js b/resources/public/js/solver-history.js
new file mode 100644
index 00000000..3178c259
--- /dev/null
+++ b/resources/public/js/solver-history.js
@@ -0,0 +1,860 @@
+/**
+ * Job history management
+ */
+
+let jobHistory = [];
+let collapsedTrees = new Set(); // Track which job IDs have their children collapsed
+
+// Get display name for scoring method
+function getScoringMethodDisplay(method) {
+ const displays = {
+ 'mae-max': 'MAE + Max',
+ 'log-cosh': 'Log-Cosh',
+ 'r-squared': 'R²'
+ };
+ return displays[method] || method || 'MAE + Max';
+}
+
+// Get display name for simplicity bias
+function getSimplicityBiasDisplay(bias) {
+ const displays = {
+ 'none': 'None',
+ 'tiebreaker': 'Tiebreaker',
+ 'light': 'Light',
+ 'strong': 'Strong'
+ };
+ return displays[bias] || bias || 'Tiebreaker';
+}
+
+// Update job label in history and refresh badge (called on every keystroke)
+function updateHistoryJobLabel(index, newLabel) {
+ const job = jobHistory[index];
+ if (job) {
+ job.label = newLabel.trim() || null;
+
+ // Update just the badge element directly
+ const badgeEl = document.getElementById(`history-label-badge-${index}`);
+ if (badgeEl) {
+ if (job.label) {
+ badgeEl.innerHTML = escapeHistoryHtml(job.label);
+ badgeEl.title = job.label;
+ badgeEl.classList.remove('hidden');
+ } else {
+ badgeEl.innerHTML = '';
+ badgeEl.classList.add('hidden');
+ }
+ }
+ }
+}
+
+// Create editable label HTML for history job
+function createHistoryEditableLabelHtml(index, label) {
+ const escapedLabel = label ? escapeHistoryHtml(label) : '';
+ return `
+
+ Label:
+
+
+ `;
+}
+
+// Escape HTML for history (local version)
+function escapeHistoryHtml(text) {
+ if (!text) return '';
+ const div = document.createElement('div');
+ div.textContent = text;
+ return div.innerHTML;
+}
+
+// Format length deduction display for history
+function formatHistoryLengthDeduction(deduction) {
+ if (!deduction || deduction === 0) return '';
+ return `(−${deduction.toFixed(4)} bias)`;
+}
+
+// Format compact scores for collapsed history view (no sparklines)
+// Shows raw scores (without length deduction) for fair comparison
+function formatCompactHistoryScores(job) {
+ const scores = job.scores;
+ const rawScores = job.rawScores;
+ const lengthDeductions = job.lengthDeductions;
+ const primaryMethod = job.scoringMethod || job.config?.scoringMethod || 'mae-max';
+
+ if (!scores) {
+ // Fallback for old history items without multi-score data
+ return `${job.score.toFixed(6)}`;
+ }
+
+ const methods = [
+ { key: 'mae-max', name: 'MAE' },
+ { key: 'log-cosh', name: 'LC' },
+ { key: 'r-squared', name: 'R²' }
+ ];
+
+ // Use raw scores for display if available
+ const displayScores = rawScores || scores;
+
+ // Check if there's any non-zero deduction for the primary method
+ const primaryDeduction = lengthDeductions ? lengthDeductions[primaryMethod] : 0;
+ const hasDeduction = primaryDeduction && primaryDeduction > 0;
+
+ const scoresHtml = methods.map(m => {
+ const isPrimary = m.key === primaryMethod;
+ const score = displayScores[m.key];
+ const scoreStr = (score !== undefined && score !== null) ? score.toFixed(4) : '--';
+ if (isPrimary) {
+ return `${m.name}: ${scoreStr}*`;
+ } else {
+ return `${m.name}: ${scoreStr}`;
+ }
+ }).join('·');
+
+ return scoresHtml + (hasDeduction ? formatHistoryLengthDeduction(primaryDeduction) : '');
+}
+
+// Format all scores for history details view - with sparklines
+// Shows raw scores (without length deduction) for fair comparison, with deduction shown separately
+function formatHistoryScores(job) {
+ const scores = job.scores;
+ const rawScores = job.rawScores;
+ const lengthDeductions = job.lengthDeductions;
+ const primaryMethod = job.scoringMethod || job.config?.scoringMethod || 'mae-max';
+ const scoreHistory = job.scoreHistory;
+
+ if (!scores) {
+ // Fallback for old history items without multi-score data
+ return `
+ Score:
+ ${job.score.toFixed(6)}
+ (${getScoringMethodDisplay(primaryMethod)})
+
`;
+ }
+
+ const methods = [
+ { key: 'mae-max', name: 'MAE + Max' },
+ { key: 'log-cosh', name: 'Log-Cosh' },
+ { key: 'r-squared', name: 'R²' }
+ ];
+
+ // Use raw scores for display if available
+ const displayScores = rawScores || scores;
+
+ return `
+
Scores (optimized for ${getScoringMethodDisplay(primaryMethod)}):
+
+ ${methods.map(m => {
+ const isPrimary = m.key === primaryMethod;
+ const score = displayScores[m.key];
+ const deduction = lengthDeductions ? lengthDeductions[m.key] : 0;
+ const scoreStr = (score !== undefined && score !== null) ? score.toFixed(6) : '--';
+ const sparkline = generateMethodSparkline(scoreHistory, m.key);
+ const deductionHtml = (deduction && deduction > 0)
+ ? `
−${deduction.toFixed(6)} bias
`
+ : '';
+ return `
+
${m.name}${isPrimary ? ' *' : ''}
+
${scoreStr}
+ ${deductionHtml}
+ ${sparkline}
+
`;
+ }).join('')}
+
+
+
+
+ ${treeToggleIcon}
+
+
+
+ ${labelBadge}
+ ${depthBadge}
+ ${improvementBadge}
+ ${statusBadge}
+ ${scoringBadge}
+ ${simplicityBadge}
+ ${datasetBadge}
+ ${childBadge}
+
+
+ ${formatCompactHistoryScores(job)}
+ ·
+ ${job.xs.length} pts${durationInfo}${iterationInfo}
+ ·
+ ${job.timestamp}
+ ${sparkline}
+
+
+
+
+
+ ${children.length > 0 ? `
+
+ ` : ''}
+
+
+
+
+
+ ${createHistoryEditableLabelHtml(index, job.label)}
+ ${formatHistoryScores(job)}
+
+
+ Complexity:
+ ${complexityInfo}
+
+
+ Iterations:
+ ${job.status === 'stopped' ? `${job.iteration}/${job.totalIterations}` : job.config.iterations}
+
+
+ Population:
+ ${job.config.population}
+
+ ${job.config.seed ? `
+ Seed:
+ ${job.config.seed}
+
` : ''}
+
+
+
+
Formula:
+
+
${job.formula}
+
+
+
+
+
+
+
Input Data (${job.xs.length} points):
+
+
X: ${job.xs.map(x => x.toFixed(4)).join(', ')}
+
Y: ${job.ys.map(y => y.toFixed(4)).join(', ')}
+
+
+
+
+
+
Formula Fit Chart
+
+
+
+
+
+
+
+ Score:
+ ${solution.score.toFixed(6)}
+
`;
+ }
+
+ const methods = [
+ { key: 'mae-max', name: 'MAE + Max' },
+ { key: 'log-cosh', name: 'Log-Cosh' },
+ { key: 'r-squared', name: 'R²' }
+ ];
+
+ // Use raw scores for display if available, fall back to adjusted scores
+ const displayScores = rawScores || scores;
+
+ return `
+ ${methods.map(m => {
+ const isPrimary = m.key === primaryMethod;
+ const score = displayScores[m.key];
+ const deduction = lengthDeductions ? lengthDeductions[m.key] : 0;
+ const scoreStr = (score !== undefined && score !== null) ? score.toFixed(6) : '--';
+ const sparkline = generateMethodSparkline(scoreHistory, m.key);
+ const deductionStr = formatLengthDeduction(deduction);
+ return `
+
${m.name}${isPrimary ? ' *' : ''}
+
${scoreStr}
+ ${deductionStr}
+ ${sparkline}
+
`;
+ }).join('')}
+
* Scoring method used for optimization
`;
+}
+
+// Format scores in a compact single-line format for other solutions
+// Shows raw scores (without length deduction) for fair comparison
+function formatCompactScores(solution, primaryMethod) {
+ const scores = solution.scores;
+ const rawScores = solution.rawScores;
+ const lengthDeductions = solution.lengthDeductions;
+
+ if (!scores) {
+ return `Score: ${solution.score.toFixed(6)}
`;
+ }
+
+ const methods = [
+ { key: 'mae-max', name: 'MAE' },
+ { key: 'log-cosh', name: 'LC' },
+ { key: 'r-squared', name: 'R²' }
+ ];
+
+ // Use raw scores for display if available
+ const displayScores = rawScores || scores;
+
+ // Check if there's any non-zero deduction for the primary method
+ const primaryDeduction = lengthDeductions ? lengthDeductions[primaryMethod] : 0;
+ const hasDeduction = primaryDeduction && primaryDeduction > 0;
+
+ return `
+ ${methods.map(m => {
+ const isPrimary = m.key === primaryMethod;
+ const score = displayScores[m.key];
+ const scoreStr = (score !== undefined && score !== null) ? score.toFixed(4) : '--';
+ return `
+ ${m.name}: ${scoreStr}${isPrimary ? '*' : ''}
+ `;
+ }).join('')}
+ ${hasDeduction ? `(−${primaryDeduction.toFixed(4)} bias)` : ''}
+
`;
+}
+
+// Format starting score comparison for jobs with a parent
+// Uses raw scores (without length deduction) for fair comparison
+function formatStartingScoreComparison(job, data) {
+ const currentMethod = data['scoring-method'] || 'mae-max';
+ // Prefer raw scores for comparison, fall back to adjusted scores
+ const currentRawScores = data['best-raw-scores'] || data['best-scores'];
+
+ // Get the current raw score for the current job's scoring method
+ const currentScore = currentRawScores && currentRawScores[currentMethod] !== undefined
+ ? currentRawScores[currentMethod]
+ : data['best-score'];
+
+ // Get the starting raw score for the same method from the parent job
+ // Prefer raw scores for fair comparison across different simplicity bias settings
+ let startScore = null;
+ if (job.startingRawScores && job.startingRawScores[currentMethod] !== undefined) {
+ startScore = job.startingRawScores[currentMethod];
+ } else if (job.startingScores && job.startingScores[currentMethod] !== undefined) {
+ // Fallback to adjusted scores if raw not available
+ startScore = job.startingScores[currentMethod];
+ } else if (job.startingScore !== null && job.startingScore !== undefined) {
+ // Fallback to primary score if method-specific score not available
+ startScore = job.startingScore;
+ }
+
+ if (startScore === null || startScore === undefined) return '';
+
+ const diff = startScore - currentScore;
+ const pctChange = startScore !== 0 ? (diff / Math.abs(startScore)) * 100 : 0;
+
+ let changeIndicator = '';
+ if (diff < 0) {
+ // Score increased (improved - higher is better)
+ changeIndicator = `(improved ${Math.abs(pctChange).toFixed(1)}%)`;
+ } else if (diff > 0) {
+ changeIndicator = `(worsened ${Math.abs(pctChange).toFixed(1)}%)`;
+ }
+
+ const methodDisplay = getScoringMethodDisplay(currentMethod);
+
+ return `
+ Starting ${methodDisplay}:
+ ${startScore.toFixed(6)}
+ →
+ Current:
+ ${currentScore.toFixed(6)}
+ ${changeIndicator}
+
`;
+}
+
+// Format length deduction display
+function formatLengthDeduction(deduction) {
+ if (!deduction || deduction === 0) return '';
+ return `−${deduction.toFixed(6)} bias
`;
+}
+
+// Format scores for progress display (during job run) - with sparklines
+// Shows raw scores (without length deduction) for fair comparison, with deduction shown separately
+function formatProgressScores(data, scoreHistory) {
+ const scores = data['best-scores'];
+ const rawScores = data['best-raw-scores'];
+ const lengthDeductions = data['length-deductions'];
+ const primaryMethod = data['scoring-method'] || 'mae-max';
+
+ if (!scores) {
+ // Fallback for progress without multi-score data
+ return `
+ Score:
+ ${data['best-score'].toFixed(6)}
+
`;
+ }
+
+ const methods = [
+ { key: 'mae-max', name: 'MAE + Max' },
+ { key: 'log-cosh', name: 'Log-Cosh' },
+ { key: 'r-squared', name: 'R²' }
+ ];
+
+ // Use raw scores for display if available, fall back to adjusted scores
+ const displayScores = rawScores || scores;
+
+ return `
+ ${methods.map(m => {
+ const isPrimary = m.key === primaryMethod;
+ const score = displayScores[m.key];
+ const deduction = lengthDeductions ? lengthDeductions[m.key] : 0;
+ const scoreStr = (score !== undefined && score !== null) ? score.toFixed(6) : '--';
+ const sparkline = generateMethodSparkline(scoreHistory, m.key);
+ const deductionStr = formatLengthDeduction(deduction);
+ return `
+
${m.name}${isPrimary ? ' *' : ''}
+
${scoreStr}
+ ${deductionStr}
+ ${sparkline}
+
`;
+ }).join('')}
+
+ Label:
+
+
+ `;
+}
+
+// Escape HTML special characters
+function escapeHtml(text) {
+ if (!text) return '';
+ const div = document.createElement('div');
+ div.textContent = text;
+ return div.innerHTML;
+}
+
+// Render all tabs (called when jobs change)
+function renderTabs() {
+ const tabsList = document.getElementById('job-tabs-list');
+ const tabsContainer = document.getElementById('job-tabs');
+
+ // Close any open overflow menu when re-rendering
+ closeTabOverflowMenu();
+
+ if (activeJobs.size === 0) {
+ tabsContainer.classList.add('hidden');
+ return;
+ }
+
+ tabsContainer.classList.remove('hidden');
+ tabsList.innerHTML = '';
+
+ const orderedJobIds = getOrderedJobIds();
+
+ // Ensure selected job is always in visible tabs (first position)
+ let visibleJobIds = [];
+ let overflowJobIds = [];
+
+ if (selectedJobId && activeJobs.has(selectedJobId)) {
+ // Selected job goes first
+ visibleJobIds.push(selectedJobId);
+ // Fill remaining visible slots with other jobs (in order)
+ const otherJobs = orderedJobIds.filter(id => id !== selectedJobId);
+ visibleJobIds = visibleJobIds.concat(otherJobs.slice(0, MAX_VISIBLE_TABS - 1));
+ overflowJobIds = otherJobs.slice(MAX_VISIBLE_TABS - 1);
+ } else {
+ visibleJobIds = orderedJobIds.slice(0, MAX_VISIBLE_TABS);
+ overflowJobIds = orderedJobIds.slice(MAX_VISIBLE_TABS);
+ }
+
+ // Render visible tabs
+ visibleJobIds.forEach(jobId => {
+ const job = activeJobs.get(jobId);
+ tabsList.appendChild(createTabElement(jobId, job));
+ });
+
+ // Render overflow dropdown if needed
+ if (overflowJobIds.length > 0) {
+ tabsList.appendChild(createOverflowDropdown(overflowJobIds));
+ }
+}
+
+// Create a single tab element
+function createTabElement(jobId, job) {
+ const tabDiv = document.createElement('div');
+ tabDiv.id = `job-tab-${jobId}`;
+ tabDiv.className = 'flex-1 px-2 py-1 text-xs rounded-t-md border-b-2 transition-colors flex items-center justify-between whitespace-nowrap cursor-pointer';
+
+ // Apply selected styling
+ if (selectedJobId === jobId) {
+ tabDiv.classList.add('bg-gray-700', 'border-blue-500', 'text-white');
+ } else {
+ tabDiv.classList.add('bg-gray-800', 'border-transparent', 'text-gray-400', 'hover:text-gray-300');
+ }
+
+ tabDiv.onclick = (e) => {
+ if (!e.target.closest('.tab-control')) {
+ selectJobTab(jobId);
+ }
+ };
+
+ const displayName = job.label || getJobDisplayName(job, true);
+ const pauseHidden = job.isPaused ? 'hidden' : '';
+ const resumeHidden = job.isPaused ? '' : 'hidden';
+
+ tabDiv.innerHTML = `
+
+
+ ${escapeHtml(displayName)}
+
+
+
+
+
+ `;
+
+ return tabDiv;
+}
+
+// Create overflow dropdown for additional tabs
+function createOverflowDropdown(overflowJobIds) {
+ const dropdown = document.createElement('div');
+ dropdown.className = 'relative';
+ dropdown.id = 'tab-overflow-dropdown';
+
+ dropdown.innerHTML = `
+
+ `;
+
+ // Store overflow job IDs for menu generation
+ dropdown.dataset.jobIds = JSON.stringify(overflowJobIds);
+
+ return dropdown;
+}
+
+function toggleTabOverflowMenu(event) {
+ event.stopPropagation();
+
+ let menu = document.getElementById('tab-overflow-menu');
+
+ if (menu) {
+ // Toggle existing menu
+ menu.remove();
+ return;
+ }
+
+ // Get the button position
+ const btn = document.getElementById('tab-overflow-btn');
+ const dropdown = document.getElementById('tab-overflow-dropdown');
+ if (!btn || !dropdown) return;
+
+ const rect = btn.getBoundingClientRect();
+ const overflowJobIds = JSON.parse(dropdown.dataset.jobIds || '[]');
+
+ // Create fixed-position menu
+ menu = document.createElement('div');
+ menu.id = 'tab-overflow-menu';
+ menu.className = 'fixed bg-gray-800 border border-gray-700 rounded-md shadow-lg min-w-48';
+ menu.style.cssText = `top: ${rect.bottom + 4}px; left: ${rect.left}px; z-index: 9999;`;
+
+ menu.innerHTML = overflowJobIds.map(jobId => {
+ const job = activeJobs.get(jobId);
+ if (!job) return '';
+ const displayName = job.label || getJobDisplayName(job);
+ const pauseHidden = job.isPaused ? 'hidden' : '';
+ const resumeHidden = job.isPaused ? '' : 'hidden';
+ return `
+
+
+
+
${escapeHtml(displayName)}
+
+
+
+
+
+
+
+
Solver running...
+ ${datasetBadge}
+
+ Waiting for first update...
+
+
+
+ `;
+ }
+}
+
+function renderProgressContent(jobId, job) {
+ const resultsDiv = document.getElementById('results');
+ const data = job.progress;
+
+ const percent = Math.round((data.iteration / data['total-iterations']) * 100);
+
+ // Calculate elapsed time and ETA
+ const elapsedMs = Date.now() - job.startTime;
+ const elapsedDisplay = formatETA(elapsedMs / 1000);
+ const iterationsCompleted = data.iteration;
+ const iterationsRemaining = data['total-iterations'] - iterationsCompleted;
+ let etaDisplay = '--';
+ if (iterationsCompleted > 0) {
+ const msPerIteration = elapsedMs / iterationsCompleted;
+ const remainingMs = msPerIteration * iterationsRemaining;
+ etaDisplay = formatETA(remainingMs / 1000);
+ }
+
+ const datasetBadge = job.datasetName
+ ? `${job.datasetName}`
+ : '';
+
+ // Check if we need to do a full render or just update dynamic parts
+ const existingDynamic = document.getElementById('progress-dynamic-content');
+
+ if (!existingDynamic) {
+ // First render - create full structure with static label section
+ disposeFitChart();
+
+ resultsDiv.innerHTML = `
+
+
+
Solver running...
+ ${datasetBadge}
+
${createEditableLabelHtml(jobId, job.label, 'job-label-input')}
+
+
+
+ `;
+ }
+
+ // Update only the dynamic content (progress bar, formula, scores)
+ const dynamicContent = document.getElementById('progress-dynamic-content');
+ if (dynamicContent) {
+ dynamicContent.innerHTML = `
+
+
+
+ Progress
+
+ Elapsed: ${elapsedDisplay}
+ ETA: ${etaDisplay}
+ ${data.iteration} / ${data['total-iterations']}
+
+
+
+
+
+
Current Best Formula:
+
+
${data['best-formula']}
+
+
+
+
+
+ Complexity:
+ ${data['best-formula-leaf-count']} nodes
+
+
+ Optimizing:
+ ${getScoringMethodDisplay(data['scoring-method'])}
+
+
+ Simplicity Bias:
+ ${getSimplicityBiasDisplay(data['simplicity-bias'])}
+
+
+ ${job.startingScore !== null ? formatStartingScoreComparison(job, data) : ''}
+ ${formatProgressScores(data, job.scoreHistory)}
+
Enter your data and click "Find Formula" to start the solver.
+
+ The genetic algorithm will evolve mathematical expressions to find
+ the best fit for your data.
+
+ `;
+}
+
+function showCompletedJobResults(job) {
+ const resultsDiv = document.getElementById('results');
+ const { data, scoreHistory, inputXs, inputYs, datasetName, label } = job;
+
+ const datasetBadge = datasetName
+ ? `${datasetName}`
+ : '';
+
+ const labelDisplay = label
+ ? `Label: ${escapeHtml(label)}
`
+ : '';
+
+ disposeFitChart();
+
+ resultsDiv.innerHTML = `
+
+
+
+
Completed!
+ ${datasetBadge}
+
+ ${labelDisplay}
+
+
+
Best Formula Found:
+
+
${data['best-solution'].formula}
+
+
+
+
+
+
+
+ Complexity:
+ ${data['best-solution'].leafCount} nodes
+
+
+ Optimized for:
+ ${getScoringMethodDisplay(data['scoring-method'])}
+
+
+ Simplicity bias:
+ ${getSimplicityBiasDisplay(data['simplicity-bias'])}
+
+
+ ${formatAllScores(data['best-solution'], data['scoring-method'], scoreHistory)}
+
+
+
+
+
Other Solutions:
+
+ ${data['all-solutions'].slice(1, 6).map((sol, i) => `
+
+
${sol.formula}
+ ${formatCompactScores(sol, data['scoring-method'])}
+
+ `).join('')}
+
+
+
Label: ${escapeHtml(label)}
`
+ : '';
+
+ const scoringMethod = progressData['scoring-method'] || config?.scoringMethod || 'mae-max';
+ const simplicityBias = progressData['simplicity-bias'] || config?.scoringMethod || 'tiebreaker';
+ const formula = progressData['best-formula'] || 'N/A';
+ const leafCount = progressData['best-formula-leaf-count'] || 'N/A';
+ const iteration = progressData['iteration'] || 0;
+ const totalIterations = progressData['total-iterations'] || 0;
+
+ disposeFitChart();
+
+ // Build scores display from progressData['best-scores']
+ // Include raw scores and length deductions for proper display
+ let scoresHtml = '';
+ const bestScores = progressData['best-scores'];
+ if (bestScores) {
+ // best-scores already has the right format: {'mae-max': ..., 'log-cosh': ..., 'r-squared': ...}
+ const bestSolution = {
+ scores: bestScores,
+ rawScores: progressData['best-raw-scores'],
+ lengthDeductions: progressData['length-deductions'],
+ score: progressData['best-score']
+ };
+ scoresHtml = formatAllScores(bestSolution, scoringMethod, scoreHistory);
+ } else if (progressData['best-score'] !== undefined) {
+ scoresHtml = `
+
+ Score (${getScoringMethodDisplay(scoringMethod)}):
+ ${formatScore(progressData['best-score'])}
+
+ `;
+ }
+
+ resultsDiv.innerHTML = `
+
+
+
+
Stopped
+
(iteration ${iteration}/${totalIterations})
+ ${datasetBadge}
+
+ ${labelDisplay}
+
+
+
Best Formula Found:
+
+
+
+
+
+
+ Complexity:
+ ${leafCount} nodes
+
+
+ Optimized for:
+ ${getScoringMethodDisplay(scoringMethod)}
+
+
+ Simplicity bias:
+ ${getSimplicityBiasDisplay(simplicityBias)}
+
+
+ ${scoresHtml}
+
+
+
+
Error
+
${data.error}
+
+
Error
+
${err.message}
+
+
Error
+
${errorMessage}
+
';
+ groupsHtml += '
Toggle by category:
';
+ groupsHtml += '
';
+
+ for (const [groupId, group] of Object.entries(MUTATION_GROUPS)) {
+ const groupMuts = getGroupMutations(groupId);
+ if (groupMuts.length === 0) continue; // Skip empty groups
+
+ const fullySelected = isGroupFullySelected(groupId);
+ const count = groupMuts.length;
+
+ groupsHtml += `
+
+ `;
+ }
+ groupsHtml += '
+
+
+
+
+
+
+
+ ${renderMutationCheckboxes()}
+
+
+
+
+ Welcome to Closyr
+
+
+ Find mathematical formulas that fit your data using genetic algorithms
+ and symbolic regression.
+
+
+
+ Start Solving
+
+
+
+
+
+
f(x)
+
Symbolic Regression
+
+ Discover the mathematical formula that best describes your data,
+ not just a fitted curve.
+
+
+
+
+
GA
+
Genetic Algorithms
+
+ Uses evolutionary computing to explore the space of possible
+ mathematical expressions.
+
+
+
+
+
RT
+
Real-time Progress
+
+ Watch the solver evolve formulas in real-time with live updates
+ via Server-Sent Events.
+
+
+
+
+
How It Works
+
+
+ -
+ Provide your data -
+ Enter X and Y values, upload a CSV file, or use a preset dataset.
+
+ -
+ Configure the solver -
+ Set the number of iterations, population size, and other parameters.
+
+ -
+ Watch it evolve -
+ The genetic algorithm will breed and mutate mathematical expressions.
+
+ -
+ Get your formula -
+ Receive the best-fit symbolic expression for your data.
+
+
+
+
+
Symbolic Regression Solver
+
+
+
+
+
+
+
+
+
Results
+
+
+
+
+
+
+
+
+
+
+
+
+
Enter your data and click "Find Formula" to start the solver.
+
+ The genetic algorithm will evolve mathematical expressions to find
+ the best fit for your data.
+
+
+
+
+
+
+
+
Usage:
+ *
+ * IFormulaConfig config = FormulaConfigBuilder.builder()
+ * .iterations(50)
+ * .populationSize(200)
+ * .maxLeafs(30)
+ * .build();
+ *
+ */
+public class FormulaConfigBuilder {
+
+ private int iterations = 20;
+ private int populationSize = 100;
+ private int maxLeafs = 40;
+ private long randomSeed = -1L;
+ private String[] mutationsWhitelist = null;
+ private String[] mutationsBlacklist = null;
+ private boolean adaptiveMode = false;
+ private boolean quietLogs = false;
+ private boolean useEvalCache = false;
+ private String scoringMethod = "mae-max";
+
+ private FormulaConfigBuilder() {
+ }
+
+ /**
+ * Create a new builder with default values.
+ */
+ public static FormulaConfigBuilder builder() {
+ return new FormulaConfigBuilder();
+ }
+
+ /**
+ * Set the number of GA iterations.
+ */
+ public FormulaConfigBuilder iterations(int iterations) {
+ this.iterations = iterations;
+ return this;
+ }
+
+ /**
+ * Set the population size.
+ */
+ public FormulaConfigBuilder populationSize(int populationSize) {
+ this.populationSize = populationSize;
+ return this;
+ }
+
+ /**
+ * Set the maximum expression tree leaf count.
+ */
+ public FormulaConfigBuilder maxLeafs(int maxLeafs) {
+ this.maxLeafs = maxLeafs;
+ return this;
+ }
+
+ /**
+ * Set the random seed for reproducible results.
+ * Use -1 for non-deterministic behavior (default).
+ */
+ public FormulaConfigBuilder randomSeed(long randomSeed) {
+ this.randomSeed = randomSeed;
+ return this;
+ }
+
+ /**
+ * Set a whitelist of mutation labels to use (only these mutations will be used).
+ */
+ public FormulaConfigBuilder mutationsWhitelist(String... labels) {
+ this.mutationsWhitelist = labels;
+ return this;
+ }
+
+ /**
+ * Set a blacklist of mutation labels to exclude (these mutations will not be used).
+ */
+ public FormulaConfigBuilder mutationsBlacklist(String... labels) {
+ this.mutationsBlacklist = labels;
+ return this;
+ }
+
+ /**
+ * Enable or disable adaptive mutation mode.
+ * When enabled, mutation rates adjust dynamically based on population diversity.
+ */
+ public FormulaConfigBuilder adaptiveMode(boolean adaptiveMode) {
+ this.adaptiveMode = adaptiveMode;
+ return this;
+ }
+
+ /**
+ * Enable or disable quiet logging mode.
+ * When enabled, detailed iteration logs are suppressed.
+ */
+ public FormulaConfigBuilder quietLogs(boolean quietLogs) {
+ this.quietLogs = quietLogs;
+ return this;
+ }
+
+ /**
+ * Enable or disable evaluation cache.
+ * When enabled, expression evaluation results are cached to avoid redundant calculations.
+ */
+ public FormulaConfigBuilder useEvalCache(boolean useEvalCache) {
+ this.useEvalCache = useEvalCache;
+ return this;
+ }
+
+ /**
+ * Set the scoring method for fitness evaluation.
+ * Valid values: "mae-max" (default), "log-cosh", "r-squared".
+ * All methods return 0 for perfect fit, negative for worse fits.
+ */
+ public FormulaConfigBuilder scoringMethod(String scoringMethod) {
+ this.scoringMethod = scoringMethod;
+ return this;
+ }
+
+ /**
+ * Build the configuration.
+ */
+ public IFormulaConfig build() {
+ return new SimpleFormulaConfig(iterations, populationSize, maxLeafs, randomSeed,
+ mutationsWhitelist, mutationsBlacklist, adaptiveMode, quietLogs, useEvalCache, scoringMethod);
+ }
+
+ /**
+ * Simple implementation of IFormulaConfig.
+ */
+ private static class SimpleFormulaConfig implements IFormulaConfig {
+ private final int iterations;
+ private final int populationSize;
+ private final int maxLeafs;
+ private final long randomSeed;
+ private final String[] mutationsWhitelist;
+ private final String[] mutationsBlacklist;
+ private final boolean adaptiveMode;
+ private final boolean quietLogs;
+ private final boolean useEvalCache;
+ private final String scoringMethod;
+
+ SimpleFormulaConfig(int iterations, int populationSize, int maxLeafs, long randomSeed,
+ String[] mutationsWhitelist, String[] mutationsBlacklist,
+ boolean adaptiveMode, boolean quietLogs, boolean useEvalCache,
+ String scoringMethod) {
+ this.iterations = iterations;
+ this.populationSize = populationSize;
+ this.maxLeafs = maxLeafs;
+ this.randomSeed = randomSeed;
+ this.mutationsWhitelist = mutationsWhitelist;
+ this.mutationsBlacklist = mutationsBlacklist;
+ this.adaptiveMode = adaptiveMode;
+ this.quietLogs = quietLogs;
+ this.useEvalCache = useEvalCache;
+ this.scoringMethod = scoringMethod;
+ }
+
+ @Override
+ public int getIterations() {
+ return iterations;
+ }
+
+ @Override
+ public int getPopulationSize() {
+ return populationSize;
+ }
+
+ @Override
+ public int getMaxLeafs() {
+ return maxLeafs;
+ }
+
+ @Override
+ public long getRandomSeed() {
+ return randomSeed;
+ }
+
+ @Override
+ public String[] getMutationsWhitelist() {
+ return mutationsWhitelist;
+ }
+
+ @Override
+ public String[] getMutationsBlacklist() {
+ return mutationsBlacklist;
+ }
+
+ @Override
+ public boolean isAdaptiveMode() {
+ return adaptiveMode;
+ }
+
+ @Override
+ public boolean isQuietLogs() {
+ return quietLogs;
+ }
+
+ @Override
+ public boolean isUseEvalCache() {
+ return useEvalCache;
+ }
+
+ @Override
+ public String getScoringMethod() {
+ return scoringMethod;
+ }
+
+ @Override
+ public String toString() {
+ return "FormulaConfig{iterations=" + iterations +
+ ", populationSize=" + populationSize +
+ ", maxLeafs=" + maxLeafs +
+ ", randomSeed=" + randomSeed +
+ ", adaptiveMode=" + adaptiveMode +
+ ", quietLogs=" + quietLogs +
+ ", useEvalCache=" + useEvalCache +
+ ", scoringMethod=" + scoringMethod + "}";
+ }
+ }
+}
diff --git a/src/main/java/org/closyr/api/IFormulaConfig.java b/src/main/java/org/closyr/api/IFormulaConfig.java
new file mode 100644
index 00000000..5c506f83
--- /dev/null
+++ b/src/main/java/org/closyr/api/IFormulaConfig.java
@@ -0,0 +1,79 @@
+package org.closyr.api;
+
+/**
+ * Configuration for the symbolic regression solver.
+ */
+public interface IFormulaConfig {
+
+ /**
+ * Get the number of GA iterations to run.
+ */
+ int getIterations();
+
+ /**
+ * Get the population size (number of candidate formulas).
+ */
+ int getPopulationSize();
+
+ /**
+ * Get the maximum number of leaf nodes allowed in expression trees.
+ */
+ int getMaxLeafs();
+
+ /**
+ * Get the random seed for reproducible results.
+ * A value of -1 means no seed is set (non-deterministic).
+ */
+ default long getRandomSeed() {
+ return -1L;
+ }
+
+ /**
+ * Get the whitelist of mutation labels to use.
+ * If null or empty, all mutations are used (subject to blacklist).
+ */
+ default String[] getMutationsWhitelist() {
+ return null;
+ }
+
+ /**
+ * Get the blacklist of mutation labels to exclude.
+ * If null or empty, no mutations are excluded.
+ */
+ default String[] getMutationsBlacklist() {
+ return null;
+ }
+
+ /**
+ * Check if adaptive mutation mode is enabled.
+ * When enabled, mutation rates adjust dynamically based on population diversity.
+ */
+ default boolean isAdaptiveMode() {
+ return false;
+ }
+
+ /**
+ * Check if quiet logging mode is enabled.
+ * When enabled, detailed iteration logs are suppressed.
+ */
+ default boolean isQuietLogs() {
+ return false;
+ }
+
+ /**
+ * Check if evaluation cache is enabled.
+ * When enabled, expression evaluation results are cached to avoid redundant calculations.
+ */
+ default boolean isUseEvalCache() {
+ return false;
+ }
+
+ /**
+ * Get the scoring method for fitness evaluation.
+ * Valid values: "mae-max" (default), "log-cosh", "r-squared".
+ * All methods return 0 for perfect fit, negative for worse fits.
+ */
+ default String getScoringMethod() {
+ return "mae-max";
+ }
+}
diff --git a/src/main/java/org/closyr/api/IFormulaFinder.java b/src/main/java/org/closyr/api/IFormulaFinder.java
new file mode 100644
index 00000000..729012c7
--- /dev/null
+++ b/src/main/java/org/closyr/api/IFormulaFinder.java
@@ -0,0 +1,26 @@
+package org.closyr.api;
+
+/**
+ * Main interface for finding formulas via symbolic regression.
+ */
+public interface IFormulaFinder {
+
+ /**
+ * Find a formula that fits the given data points.
+ *
+ * @param xs array of x values (independent variable)
+ * @param ys array of y values (dependent variable, same length as xs)
+ * @return the result containing the best formula and all solutions
+ */
+ IFormulaResult findFormula(double[] xs, double[] ys);
+
+ /**
+ * Find a formula with custom configuration.
+ *
+ * @param xs array of x values
+ * @param ys array of y values
+ * @param config solver configuration
+ * @return the result containing the best formula and all solutions
+ */
+ IFormulaResult findFormula(double[] xs, double[] ys, IFormulaConfig config);
+}
diff --git a/src/main/java/org/closyr/api/IFormulaResult.java b/src/main/java/org/closyr/api/IFormulaResult.java
new file mode 100644
index 00000000..c1978f6a
--- /dev/null
+++ b/src/main/java/org/closyr/api/IFormulaResult.java
@@ -0,0 +1,42 @@
+package org.closyr.api;
+
+import java.util.List;
+
+/**
+ * Represents the result of running the symbolic regression solver.
+ */
+public interface IFormulaResult {
+
+ /**
+ * Get the best solution found.
+ */
+ IFormulaSolution getBestSolution();
+
+ /**
+ * Get all solutions from the final population, sorted by score (best first).
+ */
+ List getAllSolutions();
+
+ /**
+ * Get the number of GA iterations that were completed.
+ */
+ int getIterationsDone();
+
+ /**
+ * Get the best formula as a string (convenience method).
+ * Equivalent to getBestSolution().getFormula().
+ */
+ default String getBestFormula() {
+ IFormulaSolution best = getBestSolution();
+ return best != null ? best.getFormula() : null;
+ }
+
+ /**
+ * Get the best score (convenience method).
+ * Equivalent to getBestSolution().getScore().
+ */
+ default double getBestScore() {
+ IFormulaSolution best = getBestSolution();
+ return best != null ? best.getScore() : Double.NEGATIVE_INFINITY;
+ }
+}
diff --git a/src/main/java/org/closyr/api/IFormulaSolution.java b/src/main/java/org/closyr/api/IFormulaSolution.java
new file mode 100644
index 00000000..6a61fbe3
--- /dev/null
+++ b/src/main/java/org/closyr/api/IFormulaSolution.java
@@ -0,0 +1,32 @@
+package org.closyr.api;
+
+import org.matheclipse.core.interfaces.IExpr;
+
+/**
+ * Represents a single formula solution from the symbolic regression solver.
+ */
+public interface IFormulaSolution {
+
+ /**
+ * Get the formula as a human-readable string (e.g., "2*x + 1").
+ */
+ String getFormula();
+
+ /**
+ * Get the fitness score. Higher (closer to 0) is better.
+ * Scores are typically negative, with 0 being a perfect fit.
+ */
+ double getScore();
+
+ /**
+ * Get the formula as a Symja IExpr for further symbolic computation.
+ * May be null if the expression couldn't be extracted.
+ */
+ IExpr getExpr();
+
+ /**
+ * Get the number of leaf nodes in the expression tree.
+ * Smaller values indicate simpler formulas.
+ */
+ int getLeafCount();
+}
diff --git a/src/main/java/org/closyr/core/FindFormula.java b/src/main/java/org/closyr/core/FindFormula.java
new file mode 100644
index 00000000..9b284dd7
--- /dev/null
+++ b/src/main/java/org/closyr/core/FindFormula.java
@@ -0,0 +1,373 @@
+package org.closyr.core;
+
+import org.closyr.api.ClojureBridge;
+import org.closyr.api.FormulaConfigBuilder;
+import org.closyr.api.IFormulaConfig;
+import org.closyr.api.IFormulaResult;
+import org.closyr.api.IFormulaSolution;
+import org.matheclipse.core.eval.EvalEngine;
+import org.matheclipse.core.eval.interfaces.AbstractFunctionOptionEvaluator;
+import org.matheclipse.core.eval.interfaces.IFunctionEvaluator;
+import org.matheclipse.core.expression.F;
+import org.matheclipse.core.expression.ImplementationStatus;
+import org.matheclipse.core.interfaces.IAST;
+import org.matheclipse.core.interfaces.IExpr;
+import org.matheclipse.core.interfaces.ISymbol;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * FindFormula - A Symja function that uses genetic algorithm-based symbolic regression
+ * to find a formula that best fits the given data points.
+ *
+ * Usage from Symja:
+ *
+ * FindFormula[{{x1, y1}, {x2, y2}, ...}, x]
+ * FindFormula[{{x1, y1}, {x2, y2}, ...}, x, n]
+ * FindFormula[{{x1, y1}, {x2, y2}, ...}, x, n, All]
+ *
+ *
+ * Usage from Java:
+ *
+ * double[] xs = {1.0, 2.0, 3.0, 4.0, 5.0};
+ * double[] ys = {2.0, 4.0, 6.0, 8.0, 10.0};
+ * FindFormula.Result result = FindFormula.findFormula(xs, ys);
+ * System.out.println("Best formula: " + result.getFormulaString());
+ * System.out.println("Score: " + result.getScore());
+ *
+ *
+ * Or use the newer API directly:
+ *
+ * import org.closyr.api.*;
+ * IFormulaResult result = FormulaFinder.find(xs, ys);
+ *
+ */
+public class FindFormula extends AbstractFunctionOptionEvaluator {
+
+ /**
+ * Result of a symbolic regression run.
+ */
+ public static class Result {
+ private final String formulaString;
+ private final double score;
+ private final IExpr formulaExpr;
+ private final int iterationsDone;
+ private final List allSolutions;
+
+ public Result(String formulaString, double score, IExpr formulaExpr,
+ int iterationsDone, List allSolutions) {
+ this.formulaString = formulaString;
+ this.score = score;
+ this.formulaExpr = formulaExpr;
+ this.iterationsDone = iterationsDone;
+ this.allSolutions = allSolutions;
+ }
+
+ /** The formula as a human-readable string (e.g., "2*x + 1") */
+ public String getFormulaString() {
+ return formulaString;
+ }
+
+ /** The fitness score (higher/closer to 0 is better, negative values) */
+ public double getScore() {
+ return score;
+ }
+
+ /** The formula as a Symja IExpr for further symbolic computation */
+ public IExpr getFormulaExpr() {
+ return formulaExpr;
+ }
+
+ /** Number of GA iterations completed */
+ public int getIterationsDone() {
+ return iterationsDone;
+ }
+
+ /** All solutions from the final population, sorted by score (best first) */
+ public List getAllSolutions() {
+ return allSolutions;
+ }
+
+ @Override
+ public String toString() {
+ return "Result{formula='" + formulaString + "', score=" + score +
+ ", iterations=" + iterationsDone + "}";
+ }
+ }
+
+ /**
+ * A single solution (phenotype) from the genetic algorithm.
+ */
+ public static class Solution {
+ private final String formulaString;
+ private final double score;
+ private final IExpr formulaExpr;
+
+ public Solution(String formulaString, double score, IExpr formulaExpr) {
+ this.formulaString = formulaString;
+ this.score = score;
+ this.formulaExpr = formulaExpr;
+ }
+
+ public String getFormulaString() {
+ return formulaString;
+ }
+
+ public double getScore() {
+ return score;
+ }
+
+ public IExpr getFormulaExpr() {
+ return formulaExpr;
+ }
+
+ @Override
+ public String toString() {
+ return "Solution{formula='" + formulaString + "', score=" + score + "}";
+ }
+ }
+
+ /**
+ * Configuration for the symbolic regression solver.
+ */
+ public static class Config {
+ private int iterations = 20;
+ private int populationSize = 100;
+ private int maxLeafs = 40;
+ private long randomSeed = -1L;
+ private String[] mutationsWhitelist = null;
+ private String[] mutationsBlacklist = null;
+ private boolean adaptiveMode = false;
+ private boolean quietLogs = false;
+ private boolean useEvalCache = false;
+ private String scoringMethod = "mae-max";
+
+ public Config() {}
+
+ /** Number of GA iterations (default: 20) */
+ public Config iterations(int iterations) {
+ this.iterations = iterations;
+ return this;
+ }
+
+ /** Population size (default: 100) */
+ public Config populationSize(int populationSize) {
+ this.populationSize = populationSize;
+ return this;
+ }
+
+ /** Maximum number of leaves in expression tree (default: 40) */
+ public Config maxLeafs(int maxLeafs) {
+ this.maxLeafs = maxLeafs;
+ return this;
+ }
+
+ /** Random seed for reproducible results (default: -1, meaning non-deterministic) */
+ public Config randomSeed(long randomSeed) {
+ this.randomSeed = randomSeed;
+ return this;
+ }
+
+ /** Whitelist of mutation labels to use (only these mutations will be used) */
+ public Config mutationsWhitelist(String... labels) {
+ this.mutationsWhitelist = labels;
+ return this;
+ }
+
+ /** Blacklist of mutation labels to exclude (these mutations will not be used) */
+ public Config mutationsBlacklist(String... labels) {
+ this.mutationsBlacklist = labels;
+ return this;
+ }
+
+ /** Enable adaptive mutation rates (default: false) */
+ public Config adaptiveMode(boolean adaptiveMode) {
+ this.adaptiveMode = adaptiveMode;
+ return this;
+ }
+
+ /** Enable quiet logging mode (default: false) */
+ public Config quietLogs(boolean quietLogs) {
+ this.quietLogs = quietLogs;
+ return this;
+ }
+
+ /** Enable evaluation cache (default: false) */
+ public Config useEvalCache(boolean useEvalCache) {
+ this.useEvalCache = useEvalCache;
+ return this;
+ }
+
+ /**
+ * Set the scoring method for fitness evaluation.
+ * Valid values: "mae-max" (default), "log-cosh", "r-squared".
+ * All methods return 0 for perfect fit, negative for worse fits.
+ */
+ public Config scoringMethod(String scoringMethod) {
+ this.scoringMethod = scoringMethod;
+ return this;
+ }
+
+ public int getIterations() { return iterations; }
+ public int getPopulationSize() { return populationSize; }
+ public int getMaxLeafs() { return maxLeafs; }
+ public long getRandomSeed() { return randomSeed; }
+ public String[] getMutationsWhitelist() { return mutationsWhitelist; }
+ public String[] getMutationsBlacklist() { return mutationsBlacklist; }
+ public boolean isAdaptiveMode() { return adaptiveMode; }
+ public boolean isQuietLogs() { return quietLogs; }
+ public boolean isUseEvalCache() { return useEvalCache; }
+ public String getScoringMethod() { return scoringMethod; }
+
+ /** Convert to IFormulaConfig for the new API */
+ IFormulaConfig toFormulaConfig() {
+ return FormulaConfigBuilder.builder()
+ .iterations(iterations)
+ .populationSize(populationSize)
+ .maxLeafs(maxLeafs)
+ .randomSeed(randomSeed)
+ .mutationsWhitelist(mutationsWhitelist)
+ .mutationsBlacklist(mutationsBlacklist)
+ .adaptiveMode(adaptiveMode)
+ .quietLogs(quietLogs)
+ .useEvalCache(useEvalCache)
+ .scoringMethod(scoringMethod)
+ .build();
+ }
+ }
+
+ public FindFormula() {
+ // empty constructor for Symja
+ }
+
+ /**
+ * Find a formula that fits the given x,y data points using default settings.
+ *
+ * @param xs array of x values
+ * @param ys array of y values (same length as xs)
+ * @return Result containing the best formula found
+ */
+ public static Result findFormula(double[] xs, double[] ys) {
+ return findFormula(xs, ys, new Config());
+ }
+
+ /**
+ * Find a formula that fits the given x,y data points with custom configuration.
+ *
+ * @param xs array of x values
+ * @param ys array of y values (same length as xs)
+ * @param config configuration for the solver
+ * @return Result containing the best formula found
+ */
+ public static Result findFormula(double[] xs, double[] ys, Config config) {
+ // Delegate to the new API via ClojureBridge
+ IFormulaConfig formulaConfig = config.toFormulaConfig();
+ IFormulaResult apiResult = ClojureBridge.find(xs, ys, formulaConfig);
+
+ // Convert to legacy Result format
+ return convertResult(apiResult);
+ }
+
+ /**
+ * Convert from the new API result to the legacy Result format.
+ */
+ private static Result convertResult(IFormulaResult apiResult) {
+ List solutions = new ArrayList<>();
+
+ for (IFormulaSolution apiSolution : apiResult.getAllSolutions()) {
+ solutions.add(new Solution(
+ apiSolution.getFormula(),
+ apiSolution.getScore(),
+ apiSolution.getExpr()
+ ));
+ }
+
+ IFormulaSolution best = apiResult.getBestSolution();
+ String bestFormula = best != null ? best.getFormula() : "x";
+ double bestScore = best != null ? best.getScore() : Double.NEGATIVE_INFINITY;
+ IExpr bestExpr = best != null ? best.getExpr() : null;
+
+ return new Result(
+ bestFormula,
+ bestScore,
+ bestExpr,
+ apiResult.getIterationsDone(),
+ solutions
+ );
+ }
+
+ // ==================== Symja Integration ====================
+
+ /**
+ * Symja function evaluator implementation.
+ * Called when FindFormula[data, x] is evaluated in Symja.
+ */
+ @Override
+ public IExpr evaluate(IAST ast, final int argSize, final IExpr[] options,
+ final EvalEngine engine, IAST originalAST) {
+ IExpr data = ast.arg1();
+ IExpr x = ast.arg2();
+
+ if (!x.isVariable()) {
+ return F.NIL;
+ }
+
+ int[] isMatrix = data.isMatrix();
+ if (isMatrix == null || isMatrix[1] != 2 || !data.isList()) {
+ return F.NIL;
+ }
+
+ IAST matrix = (IAST) data;
+ double[][] doubleMatrix = matrix.toDoubleMatrix();
+ if (doubleMatrix == null) {
+ return F.NIL;
+ }
+
+ // Extract x and y values from the matrix
+ double[] xs = new double[doubleMatrix.length];
+ double[] ys = new double[doubleMatrix.length];
+ for (int i = 0; i < doubleMatrix.length; i++) {
+ xs[i] = doubleMatrix[i][0];
+ ys[i] = doubleMatrix[i][1];
+ }
+
+ // Parse optional arguments
+ Config config = new Config();
+ if (argSize > 2) {
+ int n = ast.arg3().toIntDefault(-1);
+ if (n > 0) {
+ config.iterations(n);
+ }
+ }
+
+ try {
+ Result result = findFormula(xs, ys, config);
+ IExpr formulaExpr = result.getFormulaExpr();
+
+ if (formulaExpr != null) {
+ return formulaExpr;
+ }
+ } catch (Exception e) {
+ System.err.println("FindFormula: " + e.getMessage());
+ }
+
+ return F.NIL;
+ }
+
+ @Override
+ public int status() {
+ return ImplementationStatus.EXPERIMENTAL;
+ }
+
+ @Override
+ public int[] expectedArgSize(IAST ast) {
+ return IFunctionEvaluator.ARGS_2_4;
+ }
+
+ @Override
+ public void setUp(final ISymbol newSymbol) {
+ super.setUp(newSymbol);
+ }
+}
diff --git a/test/closyr/adaptive_test.clj b/test/closyr/adaptive_test.clj
new file mode 100644
index 00000000..b433ce1b
--- /dev/null
+++ b/test/closyr/adaptive_test.clj
@@ -0,0 +1,191 @@
+(ns closyr.adaptive-test
+ (:require
+ [clojure.test :refer :all]
+ [closyr.adaptive :as adaptive]
+ [closyr.ga :as ga]
+ [closyr.test-utils :as test-utils]))
+
+
+(use-fixtures :each
+ (fn [f]
+ (adaptive/reset-adaptive-state!)
+ (f)))
+
+
+(deftest reset-adaptive-state-test
+ (testing "reset clears all state to defaults"
+ ;; Modify state first
+ (adaptive/update-adaptive-state! [-1.0 -2.0 -3.0 -4.0 -5.0])
+ (adaptive/update-adaptive-state! [-1.0 -2.0 -3.0 -4.0 -5.0])
+
+ ;; Verify state was modified
+ (is (seq (:best-score-history (adaptive/get-adaptive-state))))
+
+ ;; Reset and verify
+ (adaptive/reset-adaptive-state!)
+ (let [state (adaptive/get-adaptive-state)]
+ (is (= 0.8 (:mutation-probability state)))
+ (is (= 1.0 (:mutation-count-boost state)))
+ (is (empty? (:best-score-history state)))
+ (is (empty? (:diversity-history state)))
+ (is (= 0 (:stagnation-counter state)))
+ (is (nil? (:last-best-score state))))))
+
+
+(deftest calculate-diversity-test
+ (testing "diversity is 0 for identical scores"
+ ;; Use 20 elements so p90 index calculation works properly
+ (is (< (adaptive/calculate-diversity (vec (repeat 20 -1.0))) 0.01)))
+
+ (testing "diversity increases with score spread"
+ ;; Create populations of 20 with different spreads
+ (let [low-spread (mapv #(- -1.0 (* 0.01 %)) (range 20)) ; -1.0 to -1.19
+ high-spread (mapv #(- -1.0 (* 0.5 %)) (range 20)) ; -1.0 to -10.5
+ low-div (adaptive/calculate-diversity low-spread)
+ high-div (adaptive/calculate-diversity high-spread)]
+ (is (< low-div high-div))))
+
+ (testing "diversity is nil for empty scores"
+ (is (nil? (adaptive/calculate-diversity []))))
+
+ (testing "diversity is capped at 1.0"
+ (let [extreme-spread (mapv #(- -1.0 (* 100.0 %)) (range 20))]
+ (is (<= (adaptive/calculate-diversity extreme-spread) 1.0)))))
+
+
+(def ^:private test-scores-a (mapv #(- -5.0 (* 0.5 %)) (range 20))) ; -5.0 to -14.5
+(def ^:private test-scores-b (mapv #(- -4.0 (* 0.5 %)) (range 20))) ; -4.0 to -13.5 (improvement)
+
+
+(deftest stagnation-detection-test
+ (testing "stagnation counter increases when no improvement"
+ (adaptive/reset-adaptive-state!)
+ ;; First update establishes baseline
+ (adaptive/update-adaptive-state! test-scores-a)
+ (is (= 0 (:stagnation-counter (adaptive/get-adaptive-state))))
+
+ ;; Same score = stagnation
+ (adaptive/update-adaptive-state! test-scores-a)
+ (is (= 1 (:stagnation-counter (adaptive/get-adaptive-state))))
+
+ ;; Still same score
+ (adaptive/update-adaptive-state! test-scores-a)
+ (is (= 2 (:stagnation-counter (adaptive/get-adaptive-state)))))
+
+ (testing "stagnation counter resets on improvement"
+ (adaptive/reset-adaptive-state!)
+ ;; Establish baseline and stagnate
+ (adaptive/update-adaptive-state! test-scores-a)
+ (adaptive/update-adaptive-state! test-scores-a)
+ (adaptive/update-adaptive-state! test-scores-a)
+ (is (= 2 (:stagnation-counter (adaptive/get-adaptive-state))))
+
+ ;; Improvement resets counter (better score = less negative)
+ (adaptive/update-adaptive-state! test-scores-b)
+ (is (= 0 (:stagnation-counter (adaptive/get-adaptive-state))))))
+
+
+(deftest mutation-probability-adjustment-test
+ (testing "mutation probability stays at baseline initially"
+ (adaptive/reset-adaptive-state!)
+ (is (= 0.8 (adaptive/get-mutation-probability))))
+
+ (testing "mutation probability increases during stagnation"
+ (adaptive/reset-adaptive-state!)
+ ;; Stagnate past threshold (20 iterations needed)
+ (dotimes [_ 25]
+ (adaptive/update-adaptive-state! test-scores-a))
+ (is (> (adaptive/get-mutation-probability) 0.8)))
+
+ (testing "mutation probability is bounded"
+ (adaptive/reset-adaptive-state!)
+ ;; Extreme stagnation
+ (dotimes [_ 50]
+ (adaptive/update-adaptive-state! test-scores-a))
+ (is (<= (adaptive/get-mutation-probability) 0.95))
+ (is (>= (adaptive/get-mutation-probability) 0.5))))
+
+
+(deftest mutation-count-boost-test
+ (testing "boost starts at 1.0"
+ (adaptive/reset-adaptive-state!)
+ (is (= 1.0 (adaptive/get-mutation-count-boost))))
+
+ (testing "boost increases during stagnation"
+ (adaptive/reset-adaptive-state!)
+ ;; Stagnate past threshold (20 iterations needed)
+ (dotimes [_ 25]
+ (adaptive/update-adaptive-state! test-scores-a))
+ (is (> (adaptive/get-mutation-count-boost) 1.0)))
+
+ (testing "boost is bounded"
+ (adaptive/reset-adaptive-state!)
+ ;; Extreme stagnation
+ (dotimes [_ 50]
+ (adaptive/update-adaptive-state! test-scores-a))
+ (is (<= (adaptive/get-mutation-count-boost) 2.0))
+ (is (>= (adaptive/get-mutation-count-boost) 0.5))))
+
+
+(deftest should-mutate-test
+ (testing "should-mutate? returns boolean"
+ (adaptive/reset-adaptive-state!)
+ (is (boolean? (adaptive/should-mutate?))))
+
+ (testing "should-mutate? respects probability distribution"
+ (adaptive/reset-adaptive-state!)
+ ;; With default 80% mutation probability, most calls should return true
+ (let [results (repeatedly 100 adaptive/should-mutate?)
+ true-count (count (filter true? results))]
+ ;; Should be roughly 80%, allow for randomness (60-95%)
+ (is (> true-count 60))
+ (is (< true-count 95)))))
+
+
+(deftest format-adaptive-status-test
+ (testing "format-adaptive-status returns a string"
+ (adaptive/reset-adaptive-state!)
+ (let [status (adaptive/format-adaptive-status)]
+ (is (string? status))
+ (is (re-find #"Adaptive:" status))
+ (is (re-find #"mut=" status))
+ (is (re-find #"boost=" status))
+ (is (re-find #"stag=" status)))))
+
+
+(deftest ga-adaptive-mode-binding-test
+ (testing "GA respects *adaptive-mode* binding when false"
+ (binding [ga/*adaptive-mode* false]
+ ;; When adaptive mode is off, should use fixed sampler
+ ;; We can't easily test the internal behavior, but we can verify it doesn't crash
+ (is (not ga/*adaptive-mode*))))
+
+ (testing "GA respects *adaptive-mode* binding when true"
+ (binding [ga/*adaptive-mode* true]
+ (is ga/*adaptive-mode*))))
+
+
+(deftest history-tracking-test
+ (testing "best score history is tracked"
+ (adaptive/reset-adaptive-state!)
+ (let [scores-1 (mapv #(- -1.0 (* 0.1 %)) (range 20)) ; best = -1.0
+ scores-2 (mapv #(- -0.5 (* 0.1 %)) (range 20)) ; best = -0.5
+ scores-3 (mapv #(- -0.3 (* 0.1 %)) (range 20))] ; best = -0.3
+ (adaptive/update-adaptive-state! scores-1)
+ (adaptive/update-adaptive-state! scores-2)
+ (adaptive/update-adaptive-state! scores-3)
+
+ (let [history (:best-score-history (adaptive/get-adaptive-state))]
+ (is (= 3 (count history)))
+ ;; Most recent first
+ (is (= -0.3 (first history))))))
+
+ (testing "history is bounded to window size"
+ (adaptive/reset-adaptive-state!)
+ ;; Add more than window size (40) entries
+ (dotimes [i 50]
+ (let [scores (mapv #(- (- i) (* 0.1 %)) (range 20))]
+ (adaptive/update-adaptive-state! scores)))
+
+ (let [history (:best-score-history (adaptive/get-adaptive-state))]
+ (is (<= (count history) 40)))))
diff --git a/test/closyr/api_test.clj b/test/closyr/api_test.clj
new file mode 100644
index 00000000..392252ba
--- /dev/null
+++ b/test/closyr/api_test.clj
@@ -0,0 +1,290 @@
+(ns closyr.api-test
+ "Tests for the Java-friendly API classes."
+ (:require
+ [clojure.test :refer :all]
+ [closyr.api.types :as types]
+ [closyr.api.finder :as finder]
+ [closyr.test-utils :as test-utils])
+ (:import
+ (org.closyr.api
+ FormulaConfigBuilder
+ FormulaFinder
+ IFormulaConfig
+ IFormulaFinder
+ IFormulaResult
+ IFormulaSolution)))
+
+
+(use-fixtures :once test-utils/quiet-logging-fixture)
+
+
+;; ============================================================================
+;; FormulaConfigBuilder tests
+;; ============================================================================
+
+(deftest test-config-builder-defaults
+ (testing "Builder creates config with default values"
+ (let [config (.build (FormulaConfigBuilder/builder))]
+ (is (instance? IFormulaConfig config))
+ (is (= 20 (.getIterations config)))
+ (is (= 100 (.getPopulationSize config)))
+ (is (= 40 (.getMaxLeafs config))))))
+
+
+(deftest test-config-builder-custom-values
+ (testing "Builder accepts custom values"
+ (let [config (-> (FormulaConfigBuilder/builder)
+ (.iterations 50)
+ (.populationSize 200)
+ (.maxLeafs 30)
+ (.build))]
+ (is (= 50 (.getIterations config)))
+ (is (= 200 (.getPopulationSize config)))
+ (is (= 30 (.getMaxLeafs config))))))
+
+
+;; ============================================================================
+;; Clojure types tests
+;; ============================================================================
+
+(deftest test-clojure-config
+ (testing "Clojure config function creates valid IFormulaConfig"
+ (let [config (types/config {:iterations 10 :population-size 50 :max-leafs 25})]
+ (is (instance? IFormulaConfig config))
+ (is (= 10 (.getIterations config)))
+ (is (= 50 (.getPopulationSize config)))
+ (is (= 25 (.getMaxLeafs config))))))
+
+
+(deftest test-clojure-config-defaults
+ (testing "Clojure config uses defaults when not specified"
+ (let [config (types/config)]
+ (is (= 20 (.getIterations config)))
+ (is (= 100 (.getPopulationSize config)))
+ (is (= 40 (.getMaxLeafs config))))))
+
+
+;; ============================================================================
+;; FormulaFinder static methods
+;; ============================================================================
+
+(deftest test-formula-finder-static-find
+ (testing "FormulaFinder.find() static method works"
+ (let [xs (double-array [1.0 2.0 3.0 4.0 5.0])
+ ys (double-array [2.0 4.0 6.0 8.0 10.0])
+ config (-> (FormulaConfigBuilder/builder)
+ (.iterations 3)
+ (.populationSize 20)
+ (.build))
+ result (FormulaFinder/find xs ys config)]
+ (is (instance? IFormulaResult result))
+ (is (pos? (.getIterationsDone result)))
+ (is (some? (.getBestSolution result)))
+ (is (string? (.getBestFormula result)))
+ (is (number? (.getBestScore result))))))
+
+
+(deftest test-formula-finder-static-find-default-config
+ (testing "FormulaFinder.find() with default config"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [1.0 4.0 9.0])
+ result (FormulaFinder/find xs ys)]
+ (is (instance? IFormulaResult result))
+ (is (= 20 (.getIterationsDone result))))))
+
+
+;; ============================================================================
+;; FormulaFinder instance methods
+;; ============================================================================
+
+(deftest test-formula-finder-instance
+ (testing "FormulaFinder instance implements IFormulaFinder"
+ (let [finder (FormulaFinder/create)]
+ (is (instance? IFormulaFinder finder)))))
+
+
+(deftest test-formula-finder-instance-find
+ (testing "FormulaFinder instance findFormula method"
+ (let [finder (FormulaFinder/create)
+ xs (double-array [1.0 2.0 3.0])
+ ys (double-array [2.0 4.0 6.0])
+ config (-> (FormulaConfigBuilder/builder)
+ (.iterations 2)
+ (.populationSize 10)
+ (.build))
+ result (.findFormula finder xs ys config)]
+ (is (instance? IFormulaResult result))
+ (is (some? (.getBestSolution result))))))
+
+
+;; ============================================================================
+;; IFormulaSolution tests
+;; ============================================================================
+
+(deftest test-formula-solution-properties
+ (testing "IFormulaSolution has expected properties"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [3.0 6.0 9.0])
+ config (-> (FormulaConfigBuilder/builder)
+ (.iterations 2)
+ (.populationSize 10)
+ (.build))
+ result (FormulaFinder/find xs ys config)
+ best (.getBestSolution result)]
+ (is (instance? IFormulaSolution best))
+ (is (string? (.getFormula best)))
+ (is (not (empty? (.getFormula best))))
+ (is (number? (.getScore best)))
+ (is (>= (.getLeafCount best) 0)))))
+
+
+(deftest test-all-solutions-sorted
+ (testing "getAllSolutions returns solutions sorted by score"
+ (let [xs (double-array [1.0 2.0 3.0 4.0])
+ ys (double-array [1.0 4.0 9.0 16.0])
+ config (-> (FormulaConfigBuilder/builder)
+ (.iterations 3)
+ (.populationSize 30)
+ (.build))
+ result (FormulaFinder/find xs ys config)
+ solutions (.getAllSolutions result)]
+ (is (seq solutions))
+ ;; Check sorted descending by score
+ (doseq [[prev curr] (partition 2 1 solutions)]
+ (is (>= (.getScore prev) (.getScore curr))
+ "Solutions should be sorted by score descending")))))
+
+
+;; ============================================================================
+;; Validation tests
+;; ============================================================================
+
+(deftest test-null-xs-throws
+ (testing "Null xs throws IllegalArgumentException"
+ (let [ys (double-array [1.0 2.0 3.0])]
+ (is (thrown-with-msg? IllegalArgumentException #"null"
+ (FormulaFinder/find nil ys))))))
+
+
+(deftest test-null-ys-throws
+ (testing "Null ys throws IllegalArgumentException"
+ (let [xs (double-array [1.0 2.0 3.0])]
+ (is (thrown-with-msg? IllegalArgumentException #"null"
+ (FormulaFinder/find xs nil))))))
+
+
+(deftest test-mismatched-lengths-throws
+ (testing "Mismatched array lengths throws IllegalArgumentException"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [1.0 2.0])]
+ (is (thrown-with-msg? IllegalArgumentException #"same length"
+ (FormulaFinder/find xs ys))))))
+
+
+(deftest test-too-few-points-throws
+ (testing "Less than 2 data points throws IllegalArgumentException"
+ (let [xs (double-array [1.0])
+ ys (double-array [2.0])]
+ (is (thrown-with-msg? IllegalArgumentException #"At least 2"
+ (FormulaFinder/find xs ys))))))
+
+
+;; ============================================================================
+;; toString tests
+;; ============================================================================
+
+(deftest test-result-to-string
+ (testing "Result toString contains expected info"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [2.0 4.0 6.0])
+ config (-> (FormulaConfigBuilder/builder)
+ (.iterations 1)
+ (.populationSize 5)
+ (.build))
+ result (FormulaFinder/find xs ys config)
+ str-repr (.toString result)]
+ (is (.contains str-repr "FormulaResult"))
+ (is (.contains str-repr "bestFormula")))))
+
+
+(deftest test-solution-to-string
+ (testing "Solution toString contains expected info"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [1.0 4.0 9.0])
+ config (-> (FormulaConfigBuilder/builder)
+ (.iterations 1)
+ (.populationSize 5)
+ (.build))
+ result (FormulaFinder/find xs ys config)
+ solution (.getBestSolution result)
+ str-repr (.toString solution)]
+ (is (.contains str-repr "FormulaSolution"))
+ (is (.contains str-repr "formula")))))
+
+
+;; ============================================================================
+;; Deterministic seed tests
+;; ============================================================================
+
+(deftest test-random-seed-produces-deterministic-results
+ (testing "Running solver with same seed produces identical results"
+ (let [xs (double-array [1.0 2.0 3.0 4.0 5.0])
+ ys (double-array [2.0 4.0 6.0 8.0 10.0])
+ seed 42
+ config (-> (FormulaConfigBuilder/builder)
+ (.iterations 3)
+ (.populationSize 20)
+ (.randomSeed seed)
+ (.build))
+ ;; Run solver twice with same seed
+ result1 (FormulaFinder/find xs ys config)
+ result2 (FormulaFinder/find xs ys config)
+ best1 (.getBestSolution result1)
+ best2 (.getBestSolution result2)]
+ ;; Results should be identical
+ (is (= (.getFormula best1) (.getFormula best2))
+ "Same seed should produce identical formulas")
+ (is (= (.getScore best1) (.getScore best2))
+ "Same seed should produce identical scores")
+ (is (= (.getLeafCount best1) (.getLeafCount best2))
+ "Same seed should produce identical leaf counts"))))
+
+
+(deftest test-different-seeds-produce-different-results
+ (testing "Running solver with different seeds produces different results"
+ (let [xs (double-array [1.0 2.0 3.0 4.0 5.0])
+ ys (double-array [1.0 4.0 9.0 16.0 25.0])
+ config1 (-> (FormulaConfigBuilder/builder)
+ (.iterations 3)
+ (.populationSize 20)
+ (.randomSeed 123)
+ (.build))
+ config2 (-> (FormulaConfigBuilder/builder)
+ (.iterations 3)
+ (.populationSize 20)
+ (.randomSeed 456)
+ (.build))
+ result1 (FormulaFinder/find xs ys config1)
+ result2 (FormulaFinder/find xs ys config2)
+ best1 (.getBestSolution result1)
+ best2 (.getBestSolution result2)
+ ;; Get all solution formulas to compare
+ all-formulas1 (set (map #(.getFormula %) (.getAllSolutions result1)))
+ all-formulas2 (set (map #(.getFormula %) (.getAllSolutions result2)))]
+ ;; The full population should differ between runs with different seeds
+ (is (not= all-formulas1 all-formulas2)
+ "Different seeds should produce different populations"))))
+
+
+(deftest test-config-builder-with-seed
+ (testing "FormulaConfigBuilder accepts random seed"
+ (let [config (-> (FormulaConfigBuilder/builder)
+ (.randomSeed 12345)
+ (.build))]
+ (is (= 12345 (.getRandomSeed config))))))
+
+
+(deftest test-clojure-config-with-seed
+ (testing "Clojure config accepts random seed"
+ (let [config (types/config {:random-seed 98765})]
+ (is (= 98765 (.getRandomSeed config))))))
diff --git a/test/closyr/benchmark_functions_test.clj b/test/closyr/benchmark_functions_test.clj
new file mode 100644
index 00000000..b31d3728
--- /dev/null
+++ b/test/closyr/benchmark_functions_test.clj
@@ -0,0 +1,446 @@
+(ns closyr.benchmark-functions-test
+ "Benchmark tests for standard symbolic regression test functions (Nguyen, Feynman)"
+ (:require
+ [clojure.test :refer :all]
+ [closyr.ops :as ops]
+ [closyr.ops.common :as ops-common]
+ [closyr.ops.initialize :as ops-init]
+ [closyr.symbolic-regression :as symreg]
+ [closyr.test-utils :as test-utils])
+ (:import
+ (java.text DecimalFormat)))
+
+
+(use-fixtures :once test-utils/quiet-logging-fixture)
+
+(alter-var-root #'symreg/*is-testing* (constantly true))
+
+
+;; =============================================================================
+;; Timing Utilities
+;; =============================================================================
+
+(def ^:private decimal-fmt (DecimalFormat. "0.00"))
+
+
+(defn- get-best-fn-str
+ "Extract the best formula string from the final population"
+ [final-population]
+ (let [{:keys [pop pop-scores]} final-population
+ best-idx (->> pop-scores
+ (map-indexed vector)
+ (apply max-key second)
+ first)
+ best-pheno (nth pop best-idx)]
+ (ops/format-fn-str (:expr best-pheno))))
+
+
+(defmacro with-timing
+ "Execute body and return [result elapsed-ms]"
+ [& body]
+ `(let [start# (System/nanoTime)
+ result# (do ~@body)
+ elapsed# (/ (- (System/nanoTime) start#) 1e6)]
+ [result# elapsed#]))
+
+
+(defn format-score [score]
+ (.format decimal-fmt score))
+
+
+(defn format-time [ms]
+ (if (>= ms 1000)
+ (str (.format decimal-fmt (/ ms 1000.0)) "s")
+ (str (.format decimal-fmt ms) "ms")))
+
+
+;; =============================================================================
+;; Benchmark Function Definitions
+;; =============================================================================
+
+(defn nguyen-4
+ "Nguyen-4: x^6 + x^5 + x^4 + x^3 + x^2 + x, x in [-1, 1]"
+ [x]
+ (+ (Math/pow x 6)
+ (Math/pow x 5)
+ (Math/pow x 4)
+ (Math/pow x 3)
+ (Math/pow x 2)
+ x))
+
+
+(defn nguyen-5
+ "Nguyen-5: sin(x^2) * cos(x) - 1, x in [-1, 1]"
+ [x]
+ (- (* (Math/sin (* x x))
+ (Math/cos x))
+ 1.0))
+
+
+(defn feynman-lorentz
+ "Lorentz factor: 1/sqrt(1 - v^2/c^2), v/c in [0, 0.95]"
+ [v-over-c]
+ (/ 1.0
+ (Math/sqrt (- 1.0 (* v-over-c v-over-c)))))
+
+
+(defn feynman-wave
+ "Wave equation: A * sin(kx - wt), with k=1, w=0.5, t=2, A=1"
+ [x]
+ (Math/sin (- x 1.0))) ; simplified: k=1, omega*t=1
+
+
+(defn feynman-diffraction
+ "Diffraction grating intensity: I = I0 * sin²(nθ/2) / sin²(θ/2), n=5, I0=1
+ From Feynman I.30.3"
+ [theta]
+ (let [n 5.0
+ half-theta (/ theta 2.0)
+ sin-half (Math/sin half-theta)
+ sin-n-half (Math/sin (* n half-theta))]
+ (if (< (Math/abs sin-half) 1e-10)
+ (* n n) ; limit as theta->0 is n²
+ (/ (* sin-n-half sin-n-half)
+ (* sin-half sin-half)))))
+
+
+(defn feynman-planck
+ "Planck radiation spectrum (simplified): x³ / (exp(x) - 1)
+ Core shape of black-body radiation. From Feynman I.41.16"
+ [x]
+ (if (< x 0.01)
+ (* x x) ; Taylor expansion near 0
+ (/ (* x x x)
+ (- (Math/exp x) 1.0))))
+
+
+(defn feynman-rutherford
+ "Rutherford scattering cross-section: 1 / sin⁴(θ/2)
+ Simplified from Feynman B1. θ in (0.1, π)"
+ [theta]
+ (let [sin-half (Math/sin (/ theta 2.0))]
+ (/ 1.0
+ (* sin-half sin-half sin-half sin-half))))
+
+
+(defn feynman-elliptical-orbit
+ "Elliptical orbit radius: r = a(1-e²) / (1 + e*cos(θ))
+ Kepler's first law. e=0.6 (eccentricity), a=1. From Feynman B3"
+ [theta]
+ (let [e 0.6
+ a 1.0]
+ (/ (* a (- 1.0 (* e e)))
+ (+ 1.0 (* e (Math/cos theta))))))
+
+
+(defn feynman-transition
+ "Quantum transition probability (sinc² function): sin²(x) / x²
+ From Feynman III.9.52: PI→II = (2πμEt/h)² × sin²((ω-ω₀)t/2) / ((ω-ω₀)t/2)²
+ Core shape where x = (ω-ω₀)t/2"
+ [x]
+ (if (< (Math/abs x) 1e-10)
+ 1.0 ; limit as x->0 is 1
+ (/ (* (Math/sin x) (Math/sin x))
+ (* x x))))
+
+
+;; =============================================================================
+;; Data Generation
+;; =============================================================================
+
+(defn generate-benchmark-data
+ "Generate x,y pairs for a benchmark function"
+ [f x-min x-max n-points]
+ (let [xs (mapv (fn [i]
+ (+ x-min
+ (* (/ i (dec (double n-points)))
+ (- x-max x-min))))
+ (range n-points))
+ ys (mapv f xs)]
+ {:xs xs :ys ys}))
+
+
+;; =============================================================================
+;; Benchmark Tests
+;; =============================================================================
+
+(deftest ^:benchmark nguyen-4-benchmark
+ (testing "Nguyen-4: polynomial x^6 + x^5 + x^4 + x^3 + x^2 + x"
+ (let [{:keys [xs ys]} (generate-benchmark-data nguyen-4 -1.0 1.0 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ ;; Best score should be negative (error) and improving
+ (is (neg? best-score))
+ ;; With random-seed 42, the resulting formula should be deterministic
+ (is (= "1/(1/50+x*Csc(x)*(-0.1-x+2*(1/10+x^2+x*Sec(x))))"
+ best-fn-str)
+ "Expected formula for Nguyen-4 with seed 42")
+ (println (str "| Nguyen-4 | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest ^:benchmark nguyen-5-benchmark
+ (testing "Nguyen-5: sin(x^2)*cos(x) - 1"
+ (let [{:keys [xs ys]} (generate-benchmark-data nguyen-5 -1.0 1.0 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ (is (neg? best-score))
+ ;; With random-seed 42, the resulting formula should be deterministic
+ (is (= "11/100+0.0009*x-Cos(1.1*x)"
+ best-fn-str)
+ "Expected formula for Nguyen-5 with seed 42")
+ (println (str "| Nguyen-5 | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest ^:benchmark feynman-lorentz-benchmark
+ (testing "Feynman Lorentz factor: 1/sqrt(1 - v^2/c^2)"
+ (let [{:keys [xs ys]} (generate-benchmark-data feynman-lorentz 0.0 0.9 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ (is (neg? best-score))
+ ;; With random-seed 42, the resulting formula should be deterministic
+ (is (= "9/10+Sqrt(x)"
+ best-fn-str)
+ "Expected formula for Feynman Lorentz with seed 42")
+ (println (str "| Feynman Lorentz | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest ^:benchmark feynman-wave-benchmark
+ (testing "Feynman Wave equation: sin(kx - wt)"
+ (let [{:keys [xs ys]} (generate-benchmark-data feynman-wave 0.0 (* 4 Math/PI) 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ (is (neg? best-score))
+ ;; With random-seed 42, the resulting formula should be deterministic
+ (is (= "-0.011*(1/100+0.009*x-Cos(x))+Sin(x)"
+ best-fn-str)
+ "Expected formula for Feynman Wave with seed 42")
+ (println (str "| Feynman Wave | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest ^:benchmark feynman-diffraction-benchmark
+ (testing "Feynman Diffraction: sin²(nθ/2) / sin²(θ/2)"
+ (let [{:keys [xs ys]} (generate-benchmark-data feynman-diffraction 0.1 (* 2 Math/PI) 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ (is (neg? best-score))
+ (println (str "| Feynman Diffraction | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest ^:benchmark feynman-planck-benchmark
+ (testing "Feynman Planck radiation: x³ / (exp(x) - 1)"
+ (let [{:keys [xs ys]} (generate-benchmark-data feynman-planck 0.1 5.0 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ (is (neg? best-score))
+ (println (str "| Feynman Planck | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest ^:benchmark feynman-rutherford-benchmark
+ (testing "Feynman Rutherford scattering: 1 / sin⁴(θ/2)"
+ (let [{:keys [xs ys]} (generate-benchmark-data feynman-rutherford 0.3 Math/PI 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ (is (neg? best-score))
+ (println (str "| Feynman Rutherford | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest ^:benchmark feynman-elliptical-orbit-benchmark
+ (testing "Feynman Elliptical orbit: a(1-e²) / (1 + e*cos(θ))"
+ (let [{:keys [xs ys]} (generate-benchmark-data feynman-elliptical-orbit 0.0 (* 2 Math/PI) 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ (is (neg? best-score))
+ (println (str "| Feynman Elliptical | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest ^:benchmark feynman-transition-benchmark
+ (testing "Feynman Transition (III.9.52): sin²(x) / x²"
+ (let [{:keys [xs ys]} (generate-benchmark-data feynman-transition (- (* 3 Math/PI)) (* 3 Math/PI) 30)
+ [{:keys [final-population iters-done]} elapsed-ms]
+ (with-timing
+ (binding [ops/*print-top-n* 1]
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 50)}
+ (fn []
+ (symreg/run-find-formula
+ {:input-phenos-count 50
+ :initial-muts (ops-init/initial-mutations)
+ :iters 50
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 42
+ :input-xs-exprs (ops-common/doubles->exprs xs)
+ :input-ys-exprs (ops-common/doubles->exprs ys)})))))
+ best-score (apply max (:pop-scores final-population))
+ best-fn-str (get-best-fn-str final-population)]
+
+ (is (= 50 (count (:pop final-population))))
+ (is (= 50 iters-done))
+ (is (neg? best-score))
+ (println (str "| Feynman Transition | " (format-score best-score)
+ " | " (format-time elapsed-ms)
+ " | fn: " best-fn-str " |")))))
+
+
+(deftest benchmark-data-generation
+ (testing "Data generation produces correct ranges"
+ (let [{:keys [xs ys]} (generate-benchmark-data nguyen-4 -1.0 1.0 10)]
+ (is (= 10 (count xs)))
+ (is (= 10 (count ys)))
+ (is (= -1.0 (first xs)))
+ (is (= 1.0 (last xs)))
+ ;; nguyen-4 at x=-1: (-1)^6 + (-1)^5 + (-1)^4 + (-1)^3 + (-1)^2 + (-1) = 1 - 1 + 1 - 1 + 1 - 1 = 0
+ (is (< (Math/abs (- (first ys) 0.0)) 1e-10))
+ ;; nguyen-4 at x=1: 1 + 1 + 1 + 1 + 1 + 1 = 6
+ (is (< (Math/abs (- (last ys) 6.0)) 1e-10)))))
diff --git a/test/closyr/core_test.clj b/test/closyr/core_test.clj
index f8f0e041..f3508ed2 100644
--- a/test/closyr/core_test.clj
+++ b/test/closyr/core_test.clj
@@ -2,7 +2,11 @@
(:require
[clojure.test :refer :all]
[closyr.core :as core]
- [closyr.symbolic-regression :as symreg]))
+ [closyr.symbolic-regression :as symreg]
+ [closyr.test-utils :as test-utils]))
+
+
+(use-fixtures :once test-utils/quiet-logging-fixture)
(deftest cli-options-test
@@ -16,17 +20,24 @@
(is (=
(let [test-input
'("-t" "-p1000" "foo" "-i" "200" "-y" "1,2,30,4,5,6,10" "-x" "0,1,2,3,4,5,6" "-l" "20" "-c"
- "-g" "debug")]
+ "-g" "debug")]
(#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
- {:headless true
- :log-level :debug
- :max-leafs 20
- :use-flamechart true
- :iterations 200
- :population 1000
- :xs [0.0 1.0 2.0 3.0 4.0 5.0 6.0]
- :ys [1.0 2.0 30.0 4.0 5.0 6.0 10.0]})))
+ {:headless true
+ :log-level :debug
+ :max-leafs 20
+ :use-flamechart true
+ :iterations 200
+ :population 1000
+ :xs [0.0 1.0 2.0 3.0 4.0 5.0 6.0]
+ :ys [1.0 2.0 30.0 4.0 5.0 6.0 10.0]
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist nil})))
(testing "if xs, also needs ys"
@@ -63,14 +74,21 @@
(let [test-input '("-t" "-p1000" "-i" "200" "-g" "wearn")]
(#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
- {:headless true,
- :log-level :info,
- :xs nil,
- :ys nil,
- :population 1000,
- :use-flamechart false,
- :iterations 200,
- :max-leafs 40})))
+ {:headless true,
+ :log-level :info,
+ :xs nil,
+ :ys nil,
+ :population 1000,
+ :use-flamechart false,
+ :iterations 200,
+ :max-leafs 40
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist nil})))
(testing "handles valid short options w csv data"
@@ -78,28 +96,42 @@
(let [test-input '("-t" "-p1000" "foo" "-i" "200" "-f" "resources/csvs/test_inputs_1.csv" "-g" "warn")]
(#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
- {:headless true
- :log-level :warn
- :max-leafs 40
- :use-flamechart false
- :iterations 200
- :population 1000
- :xs [0.0 1.0 2.0 3.0 4.0 6.0 15.0 20.0]
- :ys [1.0 1.0 1.0 2.0 3.0 0.0 -1.0 -12.0]})))
+ {:headless true
+ :log-level :warn
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs [0.0 1.0 2.0 3.0 4.0 6.0 15.0 20.0]
+ :ys [1.0 1.0 1.0 2.0 3.0 0.0 -1.0 -12.0]
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist nil})))
(testing "handles valid long options w data inline"
(is (=
(let [test-input '("--headless" "--population" "1000" "--iterations" "200" "--ys" "1,2,30,4,5,6,10" "--xs" "0,1,2,3,4,5,6" "--use-flamechart" "--max-leafs" "60" "--log-level" "error")]
(#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
- {:headless true
- :log-level :error
- :max-leafs 60
- :use-flamechart true
- :iterations 200
- :population 1000
- :xs [0.0 1.0 2.0 3.0 4.0 5.0 6.0]
- :ys [1.0 2.0 30.0 4.0 5.0 6.0 10.0]})))
+ {:headless true
+ :log-level :error
+ :max-leafs 60
+ :use-flamechart true
+ :iterations 200
+ :population 1000
+ :xs [0.0 1.0 2.0 3.0 4.0 5.0 6.0]
+ :ys [1.0 2.0 30.0 4.0 5.0 6.0 10.0]
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist nil})))
(testing "handles valid long options w csv data with columns"
@@ -107,14 +139,21 @@
(let [test-input '("--headless" "--population" "1000" "--iterations" "200" "-f" "resources/csvs/test_inputs_1.csv")]
(#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
- {:headless true
- :log-level :info
- :max-leafs 40
- :use-flamechart false
- :iterations 200
- :population 1000
- :xs [0.0 1.0 2.0 3.0 4.0 6.0 15.0 20.0]
- :ys [1.0 1.0 1.0 2.0 3.0 0.0 -1.0 -12.0]})))
+ {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs [0.0 1.0 2.0 3.0 4.0 6.0 15.0 20.0]
+ :ys [1.0 1.0 1.0 2.0 3.0 0.0 -1.0 -12.0]
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist nil})))
(testing "handles valid long options w csv data with columns with in order y,x"
@@ -122,28 +161,176 @@
(let [test-input '("--headless" "--population" "1000" "--iterations" "200" "-f" "resources/csvs/test_inputs_3.csv")]
(#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
- {:headless true
- :log-level :info
- :max-leafs 40
- :use-flamechart false
- :iterations 200
- :population 1000
- :xs [0.0 1.0 2.0 3.0 4.0 6.0 15.0 20.0 30.0 45.0 55.0 60.0]
- :ys [1.0 1.0 1.0 2.0 3.0 0.0 -1.0 -12.0 -22.0 -25.0 -10.0 10.0]})))
+ {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs [0.0 1.0 2.0 3.0 4.0 6.0 15.0 20.0 30.0 45.0 55.0 60.0]
+ :ys [1.0 1.0 1.0 2.0 3.0 0.0 -1.0 -12.0 -22.0 -25.0 -10.0 10.0]
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist nil})))
(testing "handles valid long options w csv data without columns"
(is (=
(let [test-input '("--headless" "--population" "1000" "--iterations" "200" "-f" "resources/csvs/test_inputs_2.csv")]
(#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
- {:headless true
- :log-level :info
- :max-leafs 40
- :use-flamechart false
- :iterations 200
- :population 1000
- :xs [0.0 1.0 2.0 3.0 4.0 6.0 15.0 20.0]
- :ys [1.0 1.0 1.0 2.0 3.0 0.0 -1.0 -12.0]}))))
+ {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs [0.0 1.0 2.0 3.0 4.0 6.0 15.0 20.0]
+ :ys [1.0 1.0 1.0 2.0 3.0 0.0 -1.0 -12.0]
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist nil}))))
+
+
+(deftest cli-mutations-whitelist-test
+ (testing "parses whitelist option with short flag"
+ (is (=
+ (let [test-input '("-t" "-p1000" "-i" "200" "-w" "+Sin,-Sin,+Cos")]
+ (#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
+
+ {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs nil
+ :ys nil
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist ["+Sin" "-Sin" "+Cos"]
+ :mutations-blacklist nil})))
+
+ (testing "parses whitelist option with long flag"
+ (is (=
+ (let [test-input '("--headless" "--population" "1000" "--iterations" "200"
+ "--mutations-whitelist" "+Sin,-Sin")]
+ (#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
+
+ {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs nil
+ :ys nil
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist ["+Sin" "-Sin"]
+ :mutations-blacklist nil}))))
+
+
+(deftest cli-mutations-blacklist-test
+ (testing "parses blacklist option with short flag"
+ (is (=
+ (let [test-input '("-t" "-p1000" "-i" "200" "-b" "Derivative,+Sin")]
+ (#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
+
+ {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs nil
+ :ys nil
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist ["Derivative" "+Sin"]})))
+
+ (testing "parses blacklist option with long flag"
+ (is (=
+ (let [test-input '("--headless" "--population" "1000" "--iterations" "200"
+ "--mutations-blacklist" "Derivative")]
+ (#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
+
+ {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs nil
+ :ys nil
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist nil
+ :mutations-blacklist ["Derivative"]}))))
+
+
+(deftest cli-mutations-whitelist-and-blacklist-test
+ (testing "parses both whitelist and blacklist together"
+ (is (=
+ (let [test-input '("-t" "-p1000" "-i" "200" "-w" "+Sin,-Sin,+Cos,-Cos" "-b" "+Sin")]
+ (#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))
+
+ {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs nil
+ :ys nil
+ :seed nil
+ :adaptive-mode false
+ :quiet-logs false
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist ["+Sin" "-Sin" "+Cos" "-Cos"]
+ :mutations-blacklist ["+Sin"]}))))
+
+
+(deftest cli-mutations-whitelist-and-blacklist-test-2
+ (testing "parses both whitelist and blacklist together with adaptive mode and quiet logs"
+ (is (= {:headless true
+ :log-level :info
+ :max-leafs 40
+ :use-flamechart false
+ :iterations 200
+ :population 1000
+ :xs nil
+ :ys nil
+ :seed nil
+ :adaptive-mode true
+ :quiet-logs true
+ :use-eval-cache false
+ :scoring-method :mae-max
+ :mutations-whitelist ["+Sin" "-Sin" "+Cos" "-Cos"]
+ :mutations-blacklist ["+Sin"]}
+ (let [test-input '("-t" "-p1000" "-i" "200" "-w" "+Sin,-Sin,+Cos,-Cos" "-b" "+Sin" "-a" "-q")]
+ (#'core/validate-symreg-opts (#'core/parse-main-opts test-input)))))))
(deftest main-test
diff --git a/test/closyr/find_formula_java_test.clj b/test/closyr/find_formula_java_test.clj
new file mode 100644
index 00000000..c5c5241f
--- /dev/null
+++ b/test/closyr/find_formula_java_test.clj
@@ -0,0 +1,244 @@
+(ns closyr.find-formula-java-test
+ "Tests for the Java FindFormula API that calls into Clojure symbolic regression."
+ (:require
+ [clojure.test :refer :all]
+ [closyr.test-utils :as test-utils])
+ (:import
+ (org.closyr.core
+ FindFormula
+ FindFormula$Config
+ FindFormula$Result
+ FindFormula$Solution)))
+
+
+(use-fixtures :once test-utils/quiet-logging-fixture)
+
+
+(deftest test-find-formula-with-linear-data
+ (testing "Simple linear relationship: y = 2x"
+ (let [xs (double-array [1.0 2.0 3.0 4.0 5.0])
+ ys (double-array [2.0 4.0 6.0 8.0 10.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 5)
+ (.populationSize 30))
+ result (FindFormula/findFormula xs ys config)]
+ (is (instance? FindFormula$Result result))
+ (is (string? (.getFormulaString result)))
+ (is (not (empty? (.getFormulaString result))))
+ (is (number? (.getScore result)))
+ (is (pos? (.getIterationsDone result)))
+ (is (seq (.getAllSolutions result))))))
+
+
+(deftest test-find-formula-with-default-config
+ (testing "Using default configuration"
+ (let [xs (double-array [0.0 1.0 2.0 3.0])
+ ys (double-array [1.0 2.0 5.0 10.0])
+ result (FindFormula/findFormula xs ys)]
+ (is (instance? FindFormula$Result result))
+ (is (= 20 (.getIterationsDone result))) ; default iterations
+ (is (string? (.getFormulaString result))))))
+
+
+(deftest test-result-contains-symja-expr
+ (testing "Result contains a Symja IExpr for symbolic computation"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [3.0 6.0 9.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 3)
+ (.populationSize 20))
+ result (FindFormula/findFormula xs ys config)
+ formula-expr (.getFormulaExpr result)]
+ (is (some? formula-expr) "Formula IExpr should not be null")
+ (is (string? (.toString formula-expr)))
+ (is (not (empty? (.toString formula-expr)))))))
+
+
+(deftest test-all-solutions-sorted-by-score
+ (testing "Solutions are sorted by score (best first)"
+ (let [xs (double-array [1.0 2.0 3.0 4.0])
+ ys (double-array [2.0 4.0 8.0 16.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 3)
+ (.populationSize 30))
+ result (FindFormula/findFormula xs ys config)
+ solutions (.getAllSolutions result)]
+ (is (seq solutions))
+ ;; Verify sorted by score descending (higher/closer to 0 is better)
+ (doseq [[prev curr] (partition 2 1 solutions)]
+ (is (>= (.getScore prev) (.getScore curr))
+ "Solutions should be sorted by score descending"))
+ ;; Best solution should match result's formula
+ (is (= (.getFormulaString result)
+ (.getFormulaString (first solutions))))
+ (is (= (.getScore result)
+ (.getScore (first solutions)))))))
+
+
+(deftest test-null-xs-throws-exception
+ (testing "Null xs array throws IllegalArgumentException"
+ (let [ys (double-array [1.0 2.0 3.0])]
+ (is (thrown-with-msg? IllegalArgumentException #"null"
+ (FindFormula/findFormula nil ys))))))
+
+
+(deftest test-null-ys-throws-exception
+ (testing "Null ys array throws IllegalArgumentException"
+ (let [xs (double-array [1.0 2.0 3.0])]
+ (is (thrown-with-msg? IllegalArgumentException #"null"
+ (FindFormula/findFormula xs nil))))))
+
+
+(deftest test-mismatched-array-lengths-throws-exception
+ (testing "Mismatched array lengths throws IllegalArgumentException"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [1.0 2.0])]
+ (is (thrown-with-msg? IllegalArgumentException #"same length"
+ (FindFormula/findFormula xs ys))))))
+
+
+(deftest test-too-few-data-points-throws-exception
+ (testing "Less than 2 data points throws IllegalArgumentException"
+ (let [xs (double-array [1.0])
+ ys (double-array [2.0])]
+ (is (thrown-with-msg? IllegalArgumentException #"At least 2"
+ (FindFormula/findFormula xs ys))))))
+
+
+(deftest test-config-builder
+ (testing "Config builder works correctly"
+ (let [config (-> (FindFormula$Config.)
+ (.iterations 50)
+ (.populationSize 200)
+ (.maxLeafs 30))]
+ (is (= 50 (.getIterations config)))
+ (is (= 200 (.getPopulationSize config)))
+ (is (= 30 (.getMaxLeafs config))))))
+
+
+(deftest test-result-to-string
+ (testing "Result toString includes expected fields"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [2.0 4.0 6.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 2)
+ (.populationSize 10))
+ result (FindFormula/findFormula xs ys config)
+ str-repr (.toString result)]
+ (is (string? str-repr))
+ (is (.contains str-repr "Result{"))
+ (is (.contains str-repr "formula="))
+ (is (.contains str-repr "score="))
+ (is (.contains str-repr "iterations=")))))
+
+
+(deftest test-solution-to-string
+ (testing "Solution toString includes expected fields"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [1.0 4.0 9.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 2)
+ (.populationSize 10))
+ result (FindFormula/findFormula xs ys config)
+ solution (first (.getAllSolutions result))
+ str-repr (.toString solution)]
+ (is (string? str-repr))
+ (is (.contains str-repr "Solution{"))
+ (is (.contains str-repr "formula="))
+ (is (.contains str-repr "score=")))))
+
+
+(deftest test-multiple-calls-work
+ (testing "Multiple calls to findFormula work correctly"
+ ;; Verify the API works for multiple sequential calls
+ (let [xs (double-array [1.0 2.0])
+ ys (double-array [1.0 2.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 1)
+ (.populationSize 5))
+ result1 (FindFormula/findFormula xs ys config)
+ result2 (FindFormula/findFormula xs ys config)]
+ (is (some? result1))
+ (is (some? result2)))))
+
+
+(deftest test-random-seed-deterministic
+ (testing "Running solver with same random seed produces identical results"
+ (let [xs (double-array [1.0 2.0 3.0 4.0 5.0])
+ ys (double-array [2.0 4.0 6.0 8.0 10.0])
+ seed 42
+ config (-> (FindFormula$Config.)
+ (.iterations 5)
+ (.populationSize 30)
+ (.randomSeed seed))
+ ;; Run solver twice with same seed
+ result1 (FindFormula/findFormula xs ys config)
+ result2 (FindFormula/findFormula xs ys config)]
+ ;; Results should be identical
+ (is (= (.getFormulaString result1) (.getFormulaString result2))
+ "Same seed should produce identical formulas")
+ (is (= (.getScore result1) (.getScore result2))
+ "Same seed should produce identical scores"))))
+
+
+(deftest test-random-seed-config-getter
+ (testing "Config getter for random seed works correctly"
+ (let [config (-> (FindFormula$Config.)
+ (.randomSeed 12345))]
+ (is (= 12345 (.getRandomSeed config))))))
+
+
+(deftest test-mutations-whitelist-config
+ (testing "Config accepts mutations whitelist"
+ (let [config (-> (FindFormula$Config.)
+ (.mutationsWhitelist (into-array String ["+Sin" "-Sin" "+Cos"])))]
+ (is (= ["+Sin" "-Sin" "+Cos"] (vec (.getMutationsWhitelist config))))))
+
+ (testing "Whitelist restricts mutations used"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [2.0 4.0 6.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 2)
+ (.populationSize 10)
+ (.randomSeed 42)
+ (.mutationsWhitelist (into-array String ["+Sin" "-Sin" "+Cos" "-Cos"])))]
+ ;; Should run without error
+ (let [result (FindFormula/findFormula xs ys config)]
+ (is (instance? FindFormula$Result result))
+ (is (some? (.getFormulaString result)))))))
+
+
+(deftest test-mutations-blacklist-config
+ (testing "Config accepts mutations blacklist"
+ (let [config (-> (FindFormula$Config.)
+ (.mutationsBlacklist (into-array String ["Derivative"])))]
+ (is (= ["Derivative"] (vec (.getMutationsBlacklist config))))))
+
+ (testing "Blacklist excludes mutations"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [2.0 4.0 6.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 2)
+ (.populationSize 10)
+ (.randomSeed 42)
+ (.mutationsBlacklist (into-array String ["Derivative" "+Sin"])))]
+ ;; Should run without error
+ (let [result (FindFormula/findFormula xs ys config)]
+ (is (instance? FindFormula$Result result))
+ (is (some? (.getFormulaString result)))))))
+
+
+(deftest test-mutations-whitelist-and-blacklist
+ (testing "Config accepts both whitelist and blacklist"
+ (let [xs (double-array [1.0 2.0 3.0])
+ ys (double-array [2.0 4.0 6.0])
+ config (-> (FindFormula$Config.)
+ (.iterations 2)
+ (.populationSize 10)
+ (.randomSeed 42)
+ (.mutationsWhitelist (into-array String ["+Sin" "-Sin" "+Cos" "-Cos" "*x"]))
+ (.mutationsBlacklist (into-array String ["+Sin"])))]
+ ;; Should run with whitelist - blacklist = 4 mutations
+ (let [result (FindFormula/findFormula xs ys config)]
+ (is (instance? FindFormula$Result result))
+ (is (some? (.getFormulaString result)))))))
diff --git a/test/closyr/ga_test.clj b/test/closyr/ga_test.clj
index 29fcb0e1..d37157bd 100644
--- a/test/closyr/ga_test.clj
+++ b/test/closyr/ga_test.clj
@@ -41,11 +41,11 @@
(let [new-pop (ga/evolve population)
s (reduce + 0.0 (:pop-scores new-pop))]
(when (zero? (rem i 20))
- (println i " pop score: " s))
+ #_(println i " pop score: " s))
(recur new-pop
(if (zero? s)
(do
- (println "Perfect score!")
+ #_(println "Perfect score!")
0)
(dec i)))))))
(count initial-pop)))
diff --git a/test/closyr/ops_common_test.clj b/test/closyr/ops_common_test.clj
index fae2364b..a494c98f 100644
--- a/test/closyr/ops_common_test.clj
+++ b/test/closyr/ops_common_test.clj
@@ -38,6 +38,11 @@
(str (:expr (ops-common/->phenotype x (F/Sin x) nil))))
"Sin(x)")))
+ (testing "with Hold-wrapped expr returns nil"
+ (is (= (let [x (F/Dummy "x")]
+ (ops-common/->phenotype x (F/Hold (F/Sin x)) nil))
+ nil)))
+
(testing "with expr throwing exception"
(is (=
(let [x (F/Dummy "x")]
@@ -74,6 +79,7 @@
(is (instance? IAST parsed))
(is (= (str parsed)
(str (F/Cos x))))))
+
(testing "can parse simple fn str 2"
(let [x (F/Dummy "x")
parsed (.parse (ops-common/new-eval-engine) "x+Cos(x^2)")]
@@ -95,7 +101,8 @@
{:expr "1/5+x"
:simple? true}))
(is (= @ops-common/do-not-simplify-fns*
- {"1/5+Sin(ArcSin(x))" 1}))))))))
+ {"1/5+Sin(ArcSin(x))" 1}))
+ (reset! ops-common/do-not-simplify-fns* {})))))))
(deftest simplify-with-ignore-presets
@@ -107,8 +114,8 @@
{:expr "x"
:simple? true}))
(is (= @ops-common/do-not-simplify-fns*
- {"x" 2})))
- (reset! ops-common/do-not-simplify-fns* {})))
+ {"x" 2}))
+ (reset! ops-common/do-not-simplify-fns* {}))))
(deftest simplify-test
@@ -143,7 +150,8 @@
(F/Plus (F/Cos x))
(F/Plus (F/Sqrt x)))})
:expr str))
- {:expr "1+Sqrt(x)+Cos(x)+Sin(x)+2*(Cos(ArcSin(x))+Tan(ArcSin(x)))"}))))
+ {:expr "1+Sqrt(x)+Cos(x)+Sin(x)+2*(Cos(ArcSin(x))+Tan(ArcSin(x)))"}))
+ (reset! ops-common/do-not-simplify-fns* {})))
(testing "simplify sum"
(let [x (F/Dummy "x")]
diff --git a/test/closyr/ops_eval_test.clj b/test/closyr/ops_eval_test.clj
index 9c1e2c45..ba0a186d 100644
--- a/test/closyr/ops_eval_test.clj
+++ b/test/closyr/ops_eval_test.clj
@@ -122,23 +122,27 @@
:input-xs-count 1})))
[##Inf])))
- (testing "with failing conversion throws exception"
- (is (thrown? Exception
+ (testing "with failing conversion returns infinity"
+ ;; Exceptions during conversion are caught and return infinity
+ (is (=
(with-redefs-fn {#'ops-common/expr->double (fn [_] (throw (Exception. "Test exception")))}
(fn []
(ops-eval/eval-vec-pheno
(ops-common/->phenotype x (F/Subtract F/C1 F/C1D2) nil)
{:input-xs-list (ops-common/exprs->exprs-list (ops-common/doubles->exprs [0.5]))
- :input-xs-count 1}))))))
+ :input-xs-count 1})))
+ [##Inf])))
- (testing "with failing conversion throws exception 2"
- (is (thrown? Exception
+ (testing "with failing constant input conversion returns infinity"
+ ;; Exceptions in result-args->constant-input are caught and return infinity
+ (is (=
(with-redefs-fn {#'ops-eval/result-args->constant-input (fn [_ _ _] (throw (Exception. "Test exception")))}
(fn []
(ops-eval/eval-vec-pheno
(ops-common/->phenotype x (F/Subtract x F/C1D2) nil)
{:input-xs-list (ops-common/exprs->exprs-list (ops-common/doubles->exprs [0.5 1.0]))
- :input-xs-count 1}))))))
+ :input-xs-count 1})))
+ [##Inf])))
(testing "with failing conversion handles error"
(is (=
@@ -301,4 +305,168 @@
(range 320))))))))
+(deftest eval-extended-test
+ (let [x (F/Dummy "x")]
+ (testing "eval-extended returns nil when middle-section is nil"
+ (is (= (with-redefs-fn {#'ops-eval/eval-vec-pheno (fn [_ _] nil)}
+ (fn []
+ (ops-eval/eval-extended
+ (ops-common/->phenotype x (F/Sin x) nil)
+ {:input-xs-list (ops-common/exprs->exprs-list (ops-common/doubles->exprs [1.0 2.0]))
+ :input-xs-count 2}
+ {:x-head [0.5]
+ :x-head-list (ops-common/exprs->exprs-list (ops-common/doubles->exprs [0.5]))
+ :x-tail [3.0]
+ :x-tail-list (ops-common/exprs->exprs-list (ops-common/doubles->exprs [3.0]))})))
+ nil)))
+
+ (testing "eval-extended returns nil when middle-section is empty"
+ (is (= (with-redefs-fn {#'ops-eval/eval-vec-pheno (fn [_ _] [])}
+ (fn []
+ (ops-eval/eval-extended
+ (ops-common/->phenotype x (F/Sin x) nil)
+ {:input-xs-list (ops-common/exprs->exprs-list (ops-common/doubles->exprs [1.0 2.0]))
+ :input-xs-count 2}
+ {:x-head [0.5]
+ :x-head-list (ops-common/exprs->exprs-list (ops-common/doubles->exprs [0.5]))
+ :x-tail [3.0]
+ :x-tail-list (ops-common/exprs->exprs-list (ops-common/doubles->exprs [3.0]))})))
+ nil)))))
+
+(deftest long-running-fns-test
+
+ ;; 2.55+x+(-1.33+1.31736/x^(4351/200000)+x*(9/10+0.89*Log(-3/5+x))-133/100*Log(x))^(101/100)-Log(x)
+ (testing "a known long-running fn"
+ (let [x (F/Dummy "x")
+ p (ops-common/->phenotype
+ x
+ (F/Plus (F/num 2.55)
+ (F/Plus x
+ (F/Subtract
+ (F/Power
+ (F/Plus
+ (F/num -1.33)
+ (F/Subtract
+ (F/Plus
+ (F/Divide
+ (F/num 1.31726)
+ (F/Power x (F/num (float (/ 4351 200000)))))
+ (F/Times x
+ (F/Plus
+ (F/num 0.9)
+ (F/Times (F/num 0.89)
+ (F/Log (F/Plus (F/num -0.6) x))))))
+ (F/Times (F/num 1.33)
+ (F/Log x))))
+ (F/num 1.01))
+ (F/Log x))))
+ (ops-common/new-util))]
+
+ (is (= [3.6198954469921762
+ 5.30675637508254
+ 8.028748008549133
+ 11.334902089392536
+ 15.031610064000752
+ 19.017953836452868
+ 23.233095713241145
+ 27.63672344397211
+ 32.200313077602296
+ 36.90268798682677
+ 41.72753958418945
+ 46.66194111908503
+ 51.695405636638846
+ 56.81926140603571
+ 62.02622223443477
+ 67.3100825662299
+ 72.66549536889605
+ 78.0878066313582
+ 83.57292960227778
+ 89.11724756826268
+ 94.71753754430598
+ 100.37090956267996
+ 106.07475778318434
+ 111.82672069109606
+ 117.62464837198287
+ 123.46657536234513
+ 129.3506979405347
+ 135.2753549883469
+ 141.23901174985158
+ 147.24024596055037
+ 153.27773593065334
+ 159.35025025080688
+ 165.45663885380483
+ 171.5958252165628
+ 177.76679952647245
+ 183.9686126677778
+ 190.20037090875272
+ 196.4612311906346
+ 202.75039693558395
+ 209.06711430420148
+ 215.41066884398796
+ 221.7803824790561
+ 228.17561079878726
+ 234.59574060926056
+ 241.04018771640287
+ 247.50839491410636
+ 253.99983015418005
+ 260.5139848780605
+ 267.05037249280963
+ 273.60852697614
+ 280.188001597104
+ 286.78836774070965
+ 293.4092138261243
+ 300.0501443093376
+ 306.71077876220386
+ 313.39075102068966
+ 320.08970839594997
+ 326.8073109425465
+ 333.5432307787265
+ 340.2971514542159
+ 347.068767361446
+ 353.85778318654803
+ 360.66391339681456
+ 367.4868817616474
+ 374.3264209043056
+ 381.1822718820126
+ 388.0541837922185
+ 394.94191340300966
+ 401.8452248058449
+ 408.76388908895416
+ 415.69768402988905
+ 422.64639380583674
+ 429.60980872043854
+ 436.58772494594757
+ 443.57994427966935
+ 450.58627391370453
+ 457.6065262171033
+ 464.6405185296001
+ 471.6880729661739
+ 478.74901623172957
+ 485.82317944525664
+ 492.91039797286317
+ 500.01051126913455
+ 507.12336272630375
+ 514.2487995307574
+ 521.3866725264379
+ 528.536836084731
+ 535.6991479804582
+ 542.8734692736228
+ 550.0596641965745
+ 557.2576000462905
+ 564.4671470814827
+ 571.6881784242667
+ 578.9205699661395
+ 586.1642002780333
+ 593.4189505242285
+ 600.6847043799195
+ 607.9613479522391
+ 615.2487697045685]
+ (mapv
+ ops-common/expr->double
+ (ops-eval/eval-phenotype-on-expr-args
+ p
+ (ops-common/exprs->exprs-list (ops-common/doubles->exprs (vec (range 1.0 100.0 1.0)))))))
+ "Can eval long running fn"))))
+
+
(comment (run-tests 'closyr.ops-eval-test))
diff --git a/test/closyr/ops_initialize_test.clj b/test/closyr/ops_initialize_test.clj
new file mode 100644
index 00000000..3531a0e8
--- /dev/null
+++ b/test/closyr/ops_initialize_test.clj
@@ -0,0 +1,79 @@
+(ns closyr.ops-initialize-test
+ "Tests for ops/initialize namespace, including mutation filtering"
+ (:require
+ [clojure.test :refer :all]
+ [closyr.ops.initialize :as ops-init]
+ [closyr.test-utils :as test-utils]))
+
+
+(use-fixtures :once test-utils/quiet-logging-fixture)
+
+
+(deftest test-mutation-labels
+ (testing "mutation-labels returns a vector of strings"
+ (let [labels (ops-init/mutation-labels)]
+ (is (vector? labels))
+ (is (every? string? labels))
+ (is (pos? (count labels)))
+ ;; Check some known mutation labels exist
+ (is (some #(= "+Sin" %) labels))
+ (is (some #(= "*x" %) labels))
+ (is (some #(= "Derivative" %) labels)))))
+
+
+(deftest test-filter-mutations-whitelist
+ (testing "whitelist filters to only specified mutations"
+ (let [whitelist ["+Sin" "-Sin" "+Cos"]
+ filtered (ops-init/filter-mutations {:whitelist whitelist})]
+ (is (= 3 (count filtered)))
+ (is (= (set whitelist) (set (map :label filtered))))))
+
+ (testing "whitelist with single mutation"
+ (let [filtered (ops-init/filter-mutations {:whitelist ["Derivative"]})]
+ (is (= 1 (count filtered)))
+ (is (= "Derivative" (:label (first filtered)))))))
+
+
+(deftest test-filter-mutations-blacklist
+ (testing "blacklist excludes specified mutations"
+ (let [all-count (count (ops-init/initial-mutations))
+ blacklist ["Derivative" "+Sin" "-Sin"]
+ filtered (ops-init/filter-mutations {:blacklist blacklist})]
+ (is (= (- all-count 3) (count filtered)))
+ (is (not-any? #(contains? (set blacklist) (:label %)) filtered))))
+
+ (testing "blacklist with single mutation"
+ (let [all-count (count (ops-init/initial-mutations))
+ filtered (ops-init/filter-mutations {:blacklist ["Derivative"]})]
+ (is (= (dec all-count) (count filtered)))
+ (is (not-any? #(= "Derivative" (:label %)) filtered)))))
+
+
+(deftest test-filter-mutations-whitelist-and-blacklist
+ (testing "whitelist applied first, then blacklist"
+ (let [whitelist ["+Sin" "-Sin" "+Cos" "-Cos"]
+ blacklist ["+Sin" "+Cos"]
+ filtered (ops-init/filter-mutations {:whitelist whitelist
+ :blacklist blacklist})]
+ ;; Should have only -Sin and -Cos (whitelist minus blacklist)
+ (is (= 2 (count filtered)))
+ (is (= #{"-Sin" "-Cos"} (set (map :label filtered)))))))
+
+
+(deftest test-filter-mutations-empty-result-throws
+ (testing "throws exception when filtering leaves no mutations"
+ (is (thrown-with-msg? IllegalArgumentException
+ #"No mutations remaining"
+ (ops-init/filter-mutations {:whitelist ["nonexistent"]})))
+
+ (is (thrown-with-msg? IllegalArgumentException
+ #"No mutations remaining"
+ (ops-init/filter-mutations {:whitelist ["+Sin"]
+ :blacklist ["+Sin"]})))))
+
+
+(deftest test-filter-mutations-no-filters
+ (testing "no filters returns all mutations"
+ (let [all-muts (ops-init/initial-mutations)
+ filtered (ops-init/filter-mutations {})]
+ (is (= (count all-muts) (count filtered))))))
diff --git a/test/closyr/ops_modify_test.clj b/test/closyr/ops_modify_test.clj
index c0c19348..2477db93 100644
--- a/test/closyr/ops_modify_test.clj
+++ b/test/closyr/ops_modify_test.clj
@@ -7,6 +7,7 @@
[closyr.ops.modify :as ops-modify]
[closyr.util.prng :as prng])
(:import
+ (java.util UUID)
(org.matheclipse.core.expression
F)
(org.matheclipse.core.interfaces
@@ -399,6 +400,44 @@
:expr (F/Plus x (F/Times x (F/Cos (F/Subtract x F/C1D2))))})
nil)))))))
+ ;; Test for fix: when ->phenotype returns nil in the "record new last op" branch,
+ ;; crossover should return nil (not an incomplete map like {:last-op "cros:plus"})
+ (with-redefs-fn {#'prng/rand-int (fn [maxv] (dec maxv))
+ #'prng/rand-nth (fn [coll] (first coll))
+ #'ops-common/->phenotype (fn [_ _ _] nil)}
+ (fn []
+ (with-redefs [ops-modify/crossover-sampler [:plus]]
+ (let [x (F/Dummy "x")]
+ (testing "Crossover returns nil when ->phenotype fails (new expr branch)"
+ (is (= (ops-modify/crossover
+ 100
+ {:sym x
+ :expr (F/Cos x)}
+ {:sym x
+ :expr (F/Sin x)})
+ nil)))))))
+
+ ;; Test for fix: when ->phenotype returns nil in the "keep last op" branch (discount-mod? true),
+ ;; crossover should return the original phenotype p unchanged
+ (with-redefs-fn {#'prng/rand-int (fn [maxv] (dec maxv))
+ #'prng/rand-nth (fn [coll] (first coll))
+ #'ops-common/->phenotype (fn [_ _ _] nil)}
+ (fn []
+ (with-redefs [ops-modify/crossover-sampler [:plus]
+ ;; Force discount-mod? to be true
+ ops-modify/check-modification-result (fn [_ _ _] [false true])]
+ (let [x (F/Dummy "x")
+ test-uuid (UUID/randomUUID)
+ original-pheno {:sym x :expr (F/Cos x) :id test-uuid}]
+ (testing "Crossover returns original phenotype when ->phenotype fails (discount branch)"
+ (is (= (ops-modify/crossover
+ 100
+ original-pheno
+ {:sym x
+ :expr (F/Sin x)
+ :id (UUID/randomUUID)})
+ original-pheno)))))))
+
(with-redefs-fn {#'prng/rand-int (fn [maxv] (dec maxv))
#'prng/rand-nth (fn [coll] (last coll))}
(fn []
@@ -460,6 +499,7 @@
"x^4*Cos(1/2-x)^4"))))))))
+;; initial fn that's getting modified is: x + cos(x)/sqrt(x) + x*sin(x-0.5) - 1
(def all-mods-applied-on-fn-expected
[[:modify-fn
"Derivative"
@@ -598,10 +638,10 @@
"-1-x+Cos(x)/Sqrt(-x)+x*Sin(1/2+x)"]
[:modify-leafs
"1.1*x"
- "-1+1.1*x+(0.9534625892455922*Cos(1.1*x))/Sqrt(x)-1.1*x*Sin(1/2-1.1*x)"]
+ "-1+1.1*x+(0.953463*Cos(1.1*x))/Sqrt(x)-1.1*x*Sin(1/2-1.1*x)"]
[:modify-leafs
"0.9*x"
- "-1+0.9*x+(1.0540925533894598*Cos(0.9*x))/Sqrt(x)-0.9*x*Sin(1/2-0.9*x)"]
+ "-1+0.9*x+(1.05409*Cos(0.9*x))/Sqrt(x)-0.9*x*Sin(1/2-0.9*x)"]
[:modify-leafs
"sin(x)"
"-1+Cos(Sin(x))/Sqrt(Sin(x))+Sin(x)-Sin(x)*Sin(1/2-Sin(x))"]
@@ -739,16 +779,16 @@
"1-x+Cos(x)/Sqrt(x)-x*Sin(1/2+x)"]
[:modify-branches
"b*1.1"
- "1.1*(-1+x+(1.3310000000000004*Cos(x))/Sqrt(x)-1.2100000000000002*x*Sin(1.1*(1/2-1.1*x)))"]
+ "1.1*(-1+x+(1.331*Cos(x))/Sqrt(x)-1.21*x*Sin(1.1*(1/2-1.1*x)))"]
[:modify-branches
"b*0.9"
- "0.9*(-1+x+(0.7290000000000001*Cos(x))/Sqrt(x)-0.81*x*Sin(0.9*(1/2-0.9*x)))"]
+ "0.9*(-1+x+(0.729*Cos(x))/Sqrt(x)-0.81*x*Sin(0.9*(1/2-0.9*x)))"]
[:modify-branches
"b+0.1"
- "-0.7000000000000001+x+(0.1+1/Sqrt(x))*(0.1+Cos(x))-x*(0.1+Sin(0.7-x))"]
+ "-0.7+x+(0.1+1/Sqrt(x))*(0.1+Cos(x))-x*(0.1+Sin(0.7-x))"]
[:modify-branches
"b-0.1"
- "-1.3000000000000003+x+(-0.1+1/Sqrt(x))*(-0.1+Cos(x))+x*(0.1-Sin(0.30000000000000004-x))"]])
+ "-1.3+x+(-0.1+1/Sqrt(x))*(-0.1+Cos(x))+x*(0.1-Sin(0.3-x))"]])
(deftest mutations-test
@@ -756,7 +796,7 @@
#'prng/rand (fn [] 0.0)}
(fn []
(let [x (F/Dummy "x")
- ;; x + cos(x) + x*sin(x-0.5) - 1
+ ;; x + cos(x)/sqrt(x) + x*sin(x-0.5) - 1
test-expr (.minus
(.plus x (.plus
(.divide (F/Cos x) (F/Sqrt x))
diff --git a/test/closyr/ops_test.clj b/test/closyr/ops_test.clj
index fb4d9f19..e821589c 100644
--- a/test/closyr/ops_test.clj
+++ b/test/closyr/ops_test.clj
@@ -25,7 +25,21 @@
{:max-leafs ops/default-max-leafs}
(let [x (F/Dummy "x")]
(ops-common/->phenotype x (F/Subtract (F/Times x x) F/C1D2) nil)))
- -3.0000147)))
+ -3.0000064668272377)))
+
+ (testing "eval score on Hold-wrapped expr returns min-score"
+ (is (=
+ (ops/score-fn {:input-ys-vec [0 1 2]
+ :input-xs-list (ops-common/exprs->exprs-list
+ (ops-common/doubles->exprs [0.5 1.0 2.0]))
+ :input-xs-count 3}
+ {:max-leafs ops/default-max-leafs}
+ (let [x (F/Dummy "x")]
+ ;; Manually create a phenotype with Hold-wrapped expr
+ {:sym x
+ :id (random-uuid)
+ :expr (F/Hold (F/Sin x))}))
+ ops/min-score)))
(testing "eval score on too big fn"
(is (=
@@ -68,16 +82,17 @@
(deftest compute-score-from-actuals-and-expecteds-test
(testing "simple inputs"
(let [x (F/Dummy "x")]
- (is (= (#'ops/compute-score-from-actuals-and-expecteds
+ (is (= -1.5000050968429093
+ (#'ops/compute-score-from-actuals-and-expecteds
(ops-common/->phenotype x (F/Plus (F/Sin x) F/C1D2) nil)
[0.5]
[1.0]
- 10)
- -1.500015))))
+ 10)))))
(testing "throws exception"
(let [x (F/Dummy "x")]
- (is (= (with-redefs-fn
+ (is (= ops/min-score
+ (with-redefs-fn
{#'ops/compute-residual (fn [_ _] (throw (Exception. "Test Exception")))}
(fn []
@@ -85,31 +100,121 @@
(ops-common/->phenotype x (F/Plus (F/Sin x) F/C1D2) nil)
[0.5]
[1.0]
- 10)))
-
- ops/min-score))))
+ 10)))))))
(testing "without length deduction"
(with-redefs-fn {#'ops/length-deduction (fn [score leafs] score)}
(fn []
(let [x (F/Dummy "x")]
- (is (= (#'ops/compute-score-from-actuals-and-expecteds
+ (is (= 0.0
+ (#'ops/compute-score-from-actuals-and-expecteds
(ops-common/->phenotype x (F/Plus (F/Sin x) F/C1D2) nil)
[0.5]
[1.0]
- 10)
- 0.0))))))
+ 10)))))))
(testing "without length deduction 2"
(with-redefs-fn {#'ops/length-deduction (fn [score leafs] 0)}
(fn []
(let [x (F/Dummy "x")]
- (is (= (#'ops/compute-score-from-actuals-and-expecteds
+ (is (= -1.5
+ (#'ops/compute-score-from-actuals-and-expecteds
(ops-common/->phenotype x (F/Plus (F/Sin x) F/C1D2) nil)
[0.5]
[1.0]
- 10)
- -1.5)))))))
+ 10)))))))
+
+ (testing "log-cosh scoring method"
+ (with-redefs-fn {#'ops/length-deduction (fn [score leafs] 0)}
+ (fn []
+ (let [x (F/Dummy "x")
+ ys-arr (double-array [1.0 2.0 3.0])
+ ;; Perfect predictions - log-cosh of 0 residuals = 0
+ perfect-score (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x x nil)
+ [1.0 2.0 3.0]
+ [1.0 2.0 3.0]
+ 5
+ ys-arr
+ :log-cosh)]
+ ;; Perfect fit should give score of 0 (or very close)
+ (is (< (abs perfect-score) 0.0001)))
+ (let [x (F/Dummy "x")
+ ys-arr (double-array [1.0 2.0 3.0])
+ ;; Predictions off by 1 each
+ imperfect-score (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x x nil)
+ [2.0 3.0 4.0]
+ [1.0 2.0 3.0]
+ 5
+ ys-arr
+ :log-cosh)]
+ ;; Score should be negative (log-cosh(1) ≈ 0.433)
+ (is (< imperfect-score 0))
+ (is (> imperfect-score -1.0))))))
+
+ (testing "r-squared scoring method"
+ (with-redefs-fn {#'ops/length-deduction (fn [score leafs] 0)}
+ (fn []
+ (let [x (F/Dummy "x")
+ ys-arr (double-array [1.0 2.0 3.0])
+ ;; Perfect predictions - (R² - 1) = 0
+ perfect-score (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x x nil)
+ [1.0 2.0 3.0]
+ [1.0 2.0 3.0]
+ 5
+ ys-arr
+ :r-squared)]
+ (is (= perfect-score 0.0)))
+ (let [x (F/Dummy "x")
+ ys-arr (double-array [1.0 2.0 3.0])
+ ;; Predictions = mean (2.0) - R² = 0, so (R² - 1) = -1
+ mean-score (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x x nil)
+ [2.0 2.0 2.0]
+ [1.0 2.0 3.0]
+ 5
+ ys-arr
+ :r-squared)]
+ (is (< (abs (- mean-score -1.0)) 0.0001)))
+ (let [x (F/Dummy "x")
+ ys-arr (double-array [1.0 2.0 3.0])
+ ;; Predictions worse than mean - R² < 0, so (R² - 1) < -1
+ bad-score (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x x nil)
+ [10.0 10.0 10.0]
+ [1.0 2.0 3.0]
+ 5
+ ys-arr
+ :r-squared)]
+ (is (< bad-score -1.0))))))
+
+ (testing "scoring method via dynamic var"
+ (with-redefs-fn {#'ops/length-deduction (fn [score leafs] 0)}
+ (fn []
+ (let [x (F/Dummy "x")
+ ys-arr (double-array [1.0 2.0 3.0])
+ ;; Default MAE score
+ mae-score (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x x nil)
+ [1.0 2.0 3.0]
+ [1.0 2.0 3.0]
+ 5
+ ys-arr
+ :mae-max)
+ ;; R² score via binding
+ r2-score (binding [ops/*scoring-method* :r-squared]
+ (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x x nil)
+ [1.0 2.0 3.0]
+ [1.0 2.0 3.0]
+ 5
+ ys-arr
+ ops/*scoring-method*))]
+ ;; Perfect fit: MAE gives 0, R² gives 0 (both use 0 as perfect score)
+ (is (= mae-score 0.0))
+ (is (= r2-score 0.0)))))))
(deftest mutation-fn-test
@@ -201,3 +306,223 @@
(testing "invalid input 2"
(is (= (#'ops/compute-residual ##Inf ##Inf)
ops/max-resid))))
+
+
+(deftest eval-cache-test
+ (testing "cache starts empty"
+ (ops/clear-eval-cache!)
+ (let [stats (ops/eval-cache-stats)]
+ (is (= 0 (:size stats)))))
+
+ (testing "cache is populated when enabled"
+ (ops/clear-eval-cache!)
+ (binding [ops/*use-eval-cache* true]
+ (let [run-args {:input-ys-vec [0 1 2]
+ :input-xs-list (ops-common/exprs->exprs-list
+ (ops-common/doubles->exprs [0.5 1.0 2.0]))
+ :input-xs-count 3}
+ run-config {:max-leafs ops/default-max-leafs}
+ x (F/Dummy "x")
+ pheno (ops-common/->phenotype x (F/Subtract (F/Times x x) F/C1D2) nil)]
+ ;; First call should miss
+ (ops/score-fn run-args run-config pheno)
+ (let [stats (ops/eval-cache-stats)]
+ (is (= 1 (:size stats)))
+ (is (= 1 (:misses stats)))
+ (is (= 0 (:hits stats))))
+ ;; Second call with same expr should hit
+ (ops/score-fn run-args run-config pheno)
+ (let [stats (ops/eval-cache-stats)]
+ (is (= 1 (:size stats)))
+ (is (= 1 (:misses stats)))
+ (is (= 1 (:hits stats)))))))
+
+ (testing "cache is not populated when disabled"
+ (ops/clear-eval-cache!)
+ (binding [ops/*use-eval-cache* false]
+ (let [run-args {:input-ys-vec [0 1 2]
+ :input-xs-list (ops-common/exprs->exprs-list
+ (ops-common/doubles->exprs [0.5 1.0 2.0]))
+ :input-xs-count 3}
+ run-config {:max-leafs ops/default-max-leafs}
+ x (F/Dummy "x")
+ pheno (ops-common/->phenotype x (F/Subtract (F/Times x x) F/C1D2) nil)]
+ (ops/score-fn run-args run-config pheno)
+ (ops/score-fn run-args run-config pheno)
+ (let [stats (ops/eval-cache-stats)]
+ (is (= 0 (:size stats)))))))
+
+ (testing "cache returns same score for same expression"
+ (ops/clear-eval-cache!)
+ (binding [ops/*use-eval-cache* true]
+ (let [run-args {:input-ys-vec [0 1 2]
+ :input-xs-list (ops-common/exprs->exprs-list
+ (ops-common/doubles->exprs [0.5 1.0 2.0]))
+ :input-xs-count 3}
+ run-config {:max-leafs ops/default-max-leafs}
+ x (F/Dummy "x")
+ pheno (ops-common/->phenotype x (F/Subtract (F/Times x x) F/C1D2) nil)
+ score1 (ops/score-fn run-args run-config pheno)
+ score2 (ops/score-fn run-args run-config pheno)]
+ (is (= score1 score2))
+ ;; Cache key is [expr-str scoring-method] to prevent cross-contamination
+ (is (= {["-1/2+x^2" :mae-max :tiebreaker] -3.0000064668272377}
+ @ops/eval-cache*)))))
+
+ (testing "different scoring methods have separate cache entries"
+ (ops/clear-eval-cache!)
+ (binding [ops/*use-eval-cache* true]
+ ;; Use data where x^2 is NOT a perfect fit so different scoring methods produce different scores
+ (let [run-args {:input-ys-vec [0.0 2.0 5.0] ; Not a perfect fit for x^2
+ :input-ys-arr (double-array [0.0 2.0 5.0])
+ :input-xs-list (ops-common/exprs->exprs-list
+ (ops-common/doubles->exprs [0.0 1.0 2.0]))
+ :input-xs-count 3}
+ run-config-mae {:max-leafs ops/default-max-leafs :scoring-method :mae-max}
+ run-config-r2 {:max-leafs ops/default-max-leafs :scoring-method :r-squared}
+ x (F/Dummy "x")
+ pheno (ops-common/->phenotype x (F/Times x x) nil) ; x^2 gives [0, 1, 4], not [0, 2, 5]
+ ;; Score with MAE method
+ score-mae (ops/score-fn run-args run-config-mae pheno)
+ ;; Score with R-squared method - should NOT hit cache
+ score-r2 (ops/score-fn run-args run-config-r2 pheno)]
+ ;; Different scoring methods should produce different scores for imperfect fit
+ (is (not= score-mae score-r2))
+ ;; Cache should have 2 entries (one per scoring method)
+ (is (= 2 (:size (ops/eval-cache-stats))))
+ (is (= 2 (:misses (ops/eval-cache-stats))))
+ (is (= 0 (:hits (ops/eval-cache-stats))))
+ ;; Now call again with same methods - should hit cache
+ (ops/score-fn run-args run-config-mae pheno)
+ (ops/score-fn run-args run-config-r2 pheno)
+ (is (= 2 (:hits (ops/eval-cache-stats)))))))
+
+ (testing "clear-eval-cache! resets cache"
+ (ops/clear-eval-cache!)
+ (binding [ops/*use-eval-cache* true]
+ (let [run-args {:input-ys-vec [0 1 2]
+ :input-xs-list (ops-common/exprs->exprs-list
+ (ops-common/doubles->exprs [0.5 1.0 2.0]))
+ :input-xs-count 3}
+ run-config {:max-leafs ops/default-max-leafs}
+ x (F/Dummy "x")
+ pheno (ops-common/->phenotype x (F/Subtract (F/Times x x) F/C1D2) nil)]
+ (ops/score-fn run-args run-config pheno)
+ (is (= 1 (:size (ops/eval-cache-stats))))
+ (ops/clear-eval-cache!)
+ (is (= 0 (:size (ops/eval-cache-stats))))))))
+
+
+(deftest simplicity-bias-test
+ (testing "simplicity-bias :none returns zero deduction on perfect fit"
+ (binding [ops/*simplicity-bias* :none]
+ (let [x (F/Dummy "x")
+ ys-arr (double-array [1.0 2.0 3.0])
+ ;; Perfect fit with identity function
+ score (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x x nil)
+ [1.0 2.0 3.0]
+ [1.0 2.0 3.0]
+ 5
+ ys-arr
+ :mae-max)]
+ ;; With :none bias and perfect fit, score should be exactly 0
+ (is (= score 0.0)))))
+
+ (testing "simplicity-bias :tiebreaker applies tiny deduction on imperfect fit"
+ (binding [ops/*simplicity-bias* :tiebreaker]
+ (let [x (F/Dummy "x")
+ ;; Use a complex expression that does NOT perfectly fit the data
+ ;; x^2 + sin(x) evaluated at [1, 2, 3] gives roughly [1.84, 4.91, 9.14]
+ ;; We'll use ys = [2, 5, 10] for a slight mismatch
+ complex-expr (F/Plus (F/Times x x) (F/Sin x))
+ ys-arr (double-array [2.0 5.0 10.0])
+ score (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x complex-expr nil)
+ [1.8414709848078965 4.909297426825682 9.141120008059867] ; actual f(x) values
+ [2.0 5.0 10.0]
+ 5
+ ys-arr
+ :mae-max)]
+ ;; Score should be negative (error + deduction)
+ (is (< score 0))
+ ;; The deduction component should be tiny relative to the error
+ (is (> score -5.0)))))
+
+ (testing "simplicity-bias levels have increasing deductions"
+ (let [x (F/Dummy "x")
+ ;; Use a complex expression with imperfect fit to get non-zero base score
+ ;; x^2 evaluated at [0, 1, 2] gives [0, 1, 4], we use ys = [0.5, 1.5, 4.5] for error
+ complex-expr (F/Times x x)
+ actuals [0.0 1.0 4.0]
+ expected [0.5 1.5 4.5]
+ ys-arr (double-array expected)
+ ;; Calculate scores with different bias levels
+ score-none (binding [ops/*simplicity-bias* :none]
+ (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x complex-expr nil)
+ actuals
+ expected
+ 5
+ ys-arr
+ :mae-max))
+ score-tiebreaker (binding [ops/*simplicity-bias* :tiebreaker]
+ (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x complex-expr nil)
+ actuals
+ expected
+ 5
+ ys-arr
+ :mae-max))
+ score-light (binding [ops/*simplicity-bias* :light]
+ (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x complex-expr nil)
+ actuals
+ expected
+ 5
+ ys-arr
+ :mae-max))
+ score-strong (binding [ops/*simplicity-bias* :strong]
+ (#'ops/compute-score-from-actuals-and-expecteds
+ (ops-common/->phenotype x complex-expr nil)
+ actuals
+ expected
+ 5
+ ys-arr
+ :mae-max))]
+ ;; All scores should be negative (there's error)
+ (is (< score-none 0))
+ ;; Each level should have lower (more negative) score due to larger deduction
+ ;; The deduction is proportional to abs(score), so with non-zero error we'll see differences
+ (is (>= score-none score-tiebreaker))
+ (is (>= score-tiebreaker score-light))
+ (is (>= score-light score-strong))
+ ;; At least some differences should exist (strong should be noticeably lower)
+ (is (> score-none score-strong))))
+
+ (testing "simplicity-bias default is :tiebreaker"
+ (is (= ops/*simplicity-bias* :tiebreaker)))
+
+ (testing "simplicity-bias-config has expected keys and structure"
+ (let [config @#'ops/simplicity-bias-config]
+ (is (contains? config :none))
+ (is (contains? config :tiebreaker))
+ (is (contains? config :light))
+ (is (contains? config :strong))
+ ;; Each level should have :multiplier and :cap
+ (doseq [level [:none :tiebreaker :light :strong]]
+ (is (contains? (get config level) :multiplier))
+ (is (contains? (get config level) :cap)))
+ ;; :none should have 0 multiplier and 0 cap
+ (is (= 0.0 (:multiplier (:none config))))
+ (is (= 0.0 (:cap (:none config))))
+ ;; Multipliers should have increasing values
+ (is (< (:multiplier (:tiebreaker config))
+ (:multiplier (:light config))))
+ (is (< (:multiplier (:light config))
+ (:multiplier (:strong config))))
+ ;; Caps should have increasing values
+ (is (< (:cap (:tiebreaker config))
+ (:cap (:light config))))
+ (is (< (:cap (:light config))
+ (:cap (:strong config)))))))
diff --git a/test/closyr/seeded_evolution_test.clj b/test/closyr/seeded_evolution_test.clj
new file mode 100644
index 00000000..b8a5f535
--- /dev/null
+++ b/test/closyr/seeded_evolution_test.clj
@@ -0,0 +1,556 @@
+(ns closyr.seeded-evolution-test
+ "Tests for seeding GA evolution with parsed formula strings.
+
+ This test namespace exercises the full pipeline of:
+ 1. Parsing formula strings to phenotypes
+ 2. Scoring parsed phenotypes
+ 3. Mutating parsed phenotypes
+ 4. Running mini GA evolution with seeded phenotypes
+
+ IMPORTANT: Errors are logged at ERROR level to expose real issues."
+ (:require
+ [clojure.test :refer :all]
+ [closyr.ga :as ga]
+ [closyr.ops :as ops]
+ [closyr.ops.common :as ops-common]
+ [closyr.ops.eval :as ops-eval]
+ [closyr.ops.initialize :as ops-init]
+ [closyr.util.log :as log]))
+
+
+;; Log at ERROR level during tests to expose real issues
+(defn error-logging-fixture
+ "Test fixture that sets log level to ERROR during tests to expose real issues."
+ [f]
+ (log/set-log-level! :error)
+ (f))
+
+
+(use-fixtures :once error-logging-fixture)
+
+
+;;; ============================================================================
+;;; Use functions from ops-init
+;;; ============================================================================
+
+
+;; Alias for convenience in tests
+(def parse-formula->phenotype ops-init/parse-formula->phenotype)
+(def seeded-phenotypes ops-init/seeded-phenotypes)
+
+
+;;; ============================================================================
+;;; Test Helpers
+;;; ============================================================================
+
+
+(def test-xs
+ "Test x values"
+ [0.0 0.5 1.0 1.5 2.0])
+
+
+(def test-ys
+ "Test y values (sin(x) for testing)"
+ (mapv #(Math/sin %) test-xs))
+
+
+(defn- make-test-run-args
+ "Create run-args for testing with simple x/y data"
+ []
+ (let [xs-exprs (ops-common/doubles->exprs test-xs)]
+ {:input-xs-list (ops-common/exprs->exprs-list xs-exprs)
+ :input-xs-count (count test-xs)
+ :input-xs-vec test-xs
+ :input-ys-vec test-ys
+ :input-ys-arr (double-array test-ys)}))
+
+
+(defn- make-test-run-config
+ "Create run-config for testing"
+ []
+ {:max-leafs 40
+ :iters 5})
+
+
+;;; ============================================================================
+;;; Tests - Formula Parsing
+;;; ============================================================================
+
+
+(deftest test-parse-simple-formula
+ (testing "parsing simple formulas produces valid phenotypes"
+ (let [pheno (parse-formula->phenotype "x")]
+ (is (some? pheno) "Should parse 'x'")
+ (is (= ops-common/sym-x (:sym pheno)) "sym should be sym-x")
+ (is (some? (:expr pheno)) "Should have expr")
+ (is (some? (:util pheno)) "Should have util"))
+
+ (let [pheno (parse-formula->phenotype "Sin(x)")]
+ (is (some? pheno) "Should parse 'Sin(x)'"))
+
+ (let [pheno (parse-formula->phenotype "x^2 + 2*x + 1")]
+ (is (some? pheno) "Should parse polynomial"))))
+
+
+(deftest test-parsed-symbol-is-sym-x
+ (testing "parsed expressions use sym-x, not parser's x"
+ (let [pheno (parse-formula->phenotype "x + 1")
+ expr (:expr pheno)
+ expr-str (str expr)]
+ ;; The expression should contain our sym-x, which should work with evaluation
+ (is (some? pheno))
+ ;; Most importantly: the :sym field should be sym-x
+ (is (= ops-common/sym-x (:sym pheno))))))
+
+
+(deftest test-parse-complex-formulas
+ (testing "parsing complex formulas from typical solver output"
+ (doseq [formula ["Sin(x) + Cos(x)"
+ "x^2 - 3*x + 1"
+ "Log(x + 1)"
+ "Exp(-x^2)"
+ "x/2 + Sin(x)/3"]]
+ (let [pheno (parse-formula->phenotype formula)]
+ (is (some? pheno) (str "Should parse: " formula))))))
+
+
+(deftest test-parse-invalid-formulas
+ (testing "empty formula returns nil"
+ ;; Note: Symja parser is very permissive, so most "invalid" strings will
+ ;; still parse to something. We just test that empty strings are rejected.
+ (is (nil? (parse-formula->phenotype "")))))
+
+
+;;; ============================================================================
+;;; Tests - Scoring Parsed Phenotypes
+;;; ============================================================================
+
+
+(deftest test-score-parsed-phenotype
+ (testing "parsed phenotypes can be scored without errors"
+ (let [run-args (make-test-run-args)
+ run-config (make-test-run-config)
+ score-fn (partial ops/score-fn run-args run-config)]
+
+ ;; Test scoring "Sin(x)" on sin(x) data - should have good score
+ (let [pheno (parse-formula->phenotype "Sin(x)")]
+ (is (some? pheno) "Should parse Sin(x)")
+ (let [score (score-fn pheno)]
+ (is (number? score) "Score should be a number")
+ (is (not (Double/isNaN score)) "Score should not be NaN")
+ ;; Score for correct formula should be close to 0 (perfect)
+ (is (> score -0.1) "Sin(x) should score well on sin(x) data")))
+
+ ;; Test scoring other formulas - they should all produce valid scores
+ (doseq [formula ["x" "x^2" "Cos(x)" "x + 1"]]
+ (let [pheno (parse-formula->phenotype formula)]
+ (is (some? pheno) (str "Should parse: " formula))
+ (let [score (score-fn pheno)]
+ (is (number? score) (str "Score for " formula " should be a number"))
+ (is (not (Double/isNaN score)) (str "Score for " formula " should not be NaN"))))))))
+
+
+;;; ============================================================================
+;;; Tests - Mutating Parsed Phenotypes
+;;; ============================================================================
+
+
+(deftest test-mutate-parsed-phenotype
+ (testing "parsed phenotypes can be mutated without errors"
+ (let [run-config (make-test-run-config)
+ mutations (ops-init/initial-mutations)
+ mutation-fn (partial ops/mutation-fn run-config mutations)
+ pheno1 (parse-formula->phenotype "Sin(x)")]
+
+ (is (some? pheno1) "Should parse Sin(x)")
+
+ ;; Try multiple mutations to ensure they work
+ (dotimes [_ 10]
+ (let [mutated (mutation-fn pheno1 pheno1)]
+ (is (some? mutated) "Mutation should produce a phenotype")
+ (is (some? (:expr mutated)) "Mutated should have expr")
+ (is (= ops-common/sym-x (:sym mutated)) "Mutated should have sym-x"))))))
+
+
+;;; ============================================================================
+;;; Tests - Mini GA Evolution
+;;; ============================================================================
+
+
+(deftest test-mini-evolution-with-seeded-phenotypes
+ (testing "GA evolution works with seeded phenotypes"
+ (let [run-args (make-test-run-args)
+ run-config (make-test-run-config)
+ mutations (ops-init/initial-mutations)
+
+ ;; Create seeded population
+ seed-formulas ["Sin(x)" "x" "Cos(x)" "x^2"]
+ initial-pop (seeded-phenotypes seed-formulas 0.2 10)
+
+ _ (is (= 10 (count initial-pop)) "Should have 10 phenotypes")
+
+ ;; Setup GA
+ score-fn (partial ops/score-fn run-args run-config)
+ mutation-fn (partial ops/mutation-fn run-config mutations)
+ crossover-fn (partial ops/crossover-fn run-config mutations)
+
+ ga-state (ga/initialize initial-pop score-fn mutation-fn crossover-fn)]
+
+ ;; Run 3 iterations of evolution
+ (let [final-state (loop [state ga-state
+ i 3]
+ (if (zero? i)
+ state
+ (let [evolved (ga/evolve state)]
+ (is (some? (:pop evolved)) "Should have population after evolve")
+ (is (pos? (count (:pop evolved))) "Population should not be empty")
+ ;; Check all phenotypes have valid structure
+ (doseq [p (:pop evolved)]
+ (is (some? (:expr p)) "Each phenotype should have expr")
+ (is (= ops-common/sym-x (:sym p)) "Each phenotype should have sym-x"))
+ (recur evolved (dec i)))))]
+
+ (is (some? final-state) "Evolution should complete")
+ (is (pos? (count (:pop final-state))) "Final population should not be empty")))))
+
+
+(deftest test-evolution-with-all-seeded
+ (testing "GA evolution works when 100% seeded (no fresh phenotypes)"
+ (let [run-args (make-test-run-args)
+ run-config (make-test-run-config)
+ mutations (ops-init/initial-mutations)
+
+ ;; Create 100% seeded population
+ seed-formulas ["Sin(x)" "Cos(x)" "x + 1"]
+ initial-pop (seeded-phenotypes seed-formulas 0.0 6) ; 0% fresh
+
+ _ (is (= 6 (count initial-pop)) "Should have 6 phenotypes")
+
+ ;; All should be from seeds
+ _ (doseq [p initial-pop]
+ (is (some? (:expr p)) "Each phenotype should have expr")
+ (is (= ops-common/sym-x (:sym p)) "Each phenotype should have sym-x"))
+
+ score-fn (partial ops/score-fn run-args run-config)
+ mutation-fn (partial ops/mutation-fn run-config mutations)
+ crossover-fn (partial ops/crossover-fn run-config mutations)
+
+ ga-state (ga/initialize initial-pop score-fn mutation-fn crossover-fn)]
+
+ ;; Run evolution
+ (let [evolved1 (ga/evolve ga-state)
+ evolved2 (ga/evolve evolved1)]
+ (is (pos? (count (:pop evolved2))) "Should have population after 2 iterations")))))
+
+
+#_(deftest test-evolution-preserves-valid-phenotypes
+ (testing "evolution doesn't produce corrupted phenotypes"
+ (let [run-args (make-test-run-args)
+ run-config (make-test-run-config)
+ mutations (ops-init/initial-mutations)
+
+ seed-formulas ["Sin(x) + x" "x^2 - 1"]
+ initial-pop (seeded-phenotypes seed-formulas 0.0 4)
+
+ score-fn (partial ops/score-fn run-args run-config)
+ mutation-fn (partial ops/mutation-fn run-config mutations)
+ crossover-fn (partial ops/crossover-fn run-config mutations)
+
+ ga-state (ga/initialize initial-pop score-fn mutation-fn crossover-fn)]
+
+ ;; Run 5 iterations and check for corruption
+ (loop [state ga-state
+ i 5]
+ (when (pos? i)
+ (let [evolved (ga/evolve state)]
+ ;; Check each phenotype for corruption
+ (doseq [p (:pop evolved)]
+ (is (some? (:expr p)) "Phenotype should have expr")
+ (is (= ops-common/sym-x (:sym p)) "Phenotype sym should be sym-x")
+ ;; The expression string should not contain "Function(" or "Hold("
+ (let [expr-str (str (:expr p))]
+ (is (not (.contains expr-str "Function("))
+ (str "Expression should not contain Function(: " expr-str))
+ (is (not (.contains expr-str "Hold("))
+ (str "Expression should not contain Hold(: " expr-str))))
+ (recur evolved (dec i))))))))
+
+
+#_(deftest test-longer-evolution-with-realistic-formulas
+ (testing "longer evolution with formulas similar to solver output"
+ (let [;; More data points like real solver
+ xs (mapv #(* % 0.1) (range 20))
+ ys (mapv #(+ (Math/sin %) (* 0.5 %)) xs)
+ xs-exprs (ops-common/doubles->exprs xs)
+ run-args {:input-xs-list (ops-common/exprs->exprs-list xs-exprs)
+ :input-xs-count (count xs)
+ :input-xs-vec xs
+ :input-ys-vec ys
+ :input-ys-arr (double-array ys)}
+ run-config {:max-leafs 40 :iters 20}
+ mutations (ops-init/initial-mutations)
+
+ ;; Use formulas that look like solver output
+ seed-formulas ["Sin(x)+x/2"
+ "x+Sin(x)"
+ "0.5*x+Sin(x)"
+ "Sin(x)+0.5*x"
+ "x/2+Sin(x)"]
+ initial-pop (seeded-phenotypes seed-formulas 0.2 20)
+
+ _ (log/debug "Created initial pop of" (count initial-pop) "phenotypes")
+ _ (doseq [p (take 3 initial-pop)]
+ (log/debug " Initial phenotype:" (str (:expr p)) "sym:" (:sym p)))
+
+ score-fn (partial ops/score-fn run-args run-config)
+ mutation-fn (partial ops/mutation-fn run-config mutations)
+ crossover-fn (partial ops/crossover-fn run-config mutations)
+
+ ga-state (ga/initialize initial-pop score-fn mutation-fn crossover-fn)]
+
+ ;; Run 20 iterations like a real solver would
+ (loop [state ga-state
+ i 20]
+ (when (pos? i)
+ (let [evolved (ga/evolve state)]
+ ;; Check for corruption
+ (doseq [p (:pop evolved)]
+ (let [expr-str (str (:expr p))]
+ (when (.contains expr-str "Function(")
+ (log/debug "CORRUPTION DETECTED at iteration" (- 20 i) ":" expr-str))
+ (is (not (.contains expr-str "Function("))
+ (str "Expression corrupted with Function(: " expr-str))
+ (is (not (.contains expr-str "Hold("))
+ (str "Expression corrupted with Hold(: " expr-str))))
+ (recur evolved (dec i)))))
+
+ ;; Verify we completed without throwing
+ (is true "Evolution completed without throwing"))))
+
+
+#_(deftest test-evolution-with-complex-solver-formulas
+ (testing "evolution with complex formulas that might come from solver"
+ (let [xs (mapv #(* % 0.1) (range 20))
+ ys (mapv #(Math/sin %) xs)
+ xs-exprs (ops-common/doubles->exprs xs)
+ run-args {:input-xs-list (ops-common/exprs->exprs-list xs-exprs)
+ :input-xs-count (count xs)
+ :input-xs-vec xs
+ :input-ys-vec ys
+ :input-ys-arr (double-array ys)}
+ run-config {:max-leafs 40 :iters 10}
+ mutations (ops-init/initial-mutations)
+
+ ;; Complex formulas with fractions and nested operations
+ seed-formulas ["1/2*Sin(x)+1/10"
+ "Sin(x)-1/100"
+ "1/10+Sin(x)+1/100"
+ "0.538165*Sin(x)"
+ "Sin(x)^(1/2)"
+ "Log(1+x)"
+ "Exp(-x/10)"
+ "Cos(x)+Sin(x)/2"
+ "x^2/10+Sin(x)"
+ "1/(1+x^2)"]
+ initial-pop (seeded-phenotypes seed-formulas 0.0 10)]
+
+ (log/debug "Testing complex formulas:")
+ (doseq [p initial-pop]
+ (log/debug " Parsed:" (str (:expr p))))
+
+ ;; Just verify they all parsed correctly
+ (is (= 10 (count initial-pop)) "All formulas should parse")
+ (doseq [p initial-pop]
+ (is (= ops-common/sym-x (:sym p)) "All should have sym-x"))
+
+ ;; Run a few iterations
+ (let [score-fn (partial ops/score-fn run-args run-config)
+ mutation-fn (partial ops/mutation-fn run-config mutations)
+ crossover-fn (partial ops/crossover-fn run-config mutations)
+ ga-state (ga/initialize initial-pop score-fn mutation-fn crossover-fn)]
+
+ (loop [state ga-state
+ i 10]
+ (when (pos? i)
+ (let [evolved (ga/evolve state)]
+ (doseq [p (:pop evolved)]
+ (let [expr-str (str (:expr p))]
+ (when (or (.contains expr-str "Function(")
+ (.contains expr-str "Hold("))
+ (log/debug "CORRUPTION at iter" (- 10 i) ":" expr-str))
+ (is (not (.contains expr-str "Function(")) expr-str)
+ (is (not (.contains expr-str "Hold(")) expr-str)))
+ (recur evolved (dec i))))))))
+
+
+#_(deftest test-intensive-evolution-like-real-solver
+ (testing "intensive evolution matching real solver settings (100 pop, 50+ iters)"
+ (let [;; Use 20 points like the real case
+ xs (mapv #(* % 0.1) (range 20))
+ ys (mapv #(Math/sin %) xs)
+ xs-exprs (ops-common/doubles->exprs xs)
+ run-args {:input-xs-list (ops-common/exprs->exprs-list xs-exprs)
+ :input-xs-count (count xs)
+ :input-xs-vec xs
+ :input-ys-vec ys
+ :input-ys-arr (double-array ys)}
+ run-config {:max-leafs 40 :iters 50}
+ mutations (ops-init/initial-mutations)
+
+ ;; 10 seed formulas, expanded to 100 pop with 20% fresh
+ seed-formulas ["Sin(x)"
+ "0.538165*Sin(x)"
+ "Sin(x)+0.1"
+ "x+Sin(x)"
+ "Sin(x)*Cos(x)"
+ "Sin(x)^2"
+ "Sin(2*x)/2"
+ "Sin(x)+Sin(2*x)/10"
+ "Sin(x)-x/100"
+ "Sin(x)+x^2/100"]
+ initial-pop (seeded-phenotypes seed-formulas 0.2 100)
+
+ _ (log/debug "Intensive test: pop=" (count initial-pop))
+
+ score-fn (partial ops/score-fn run-args run-config)
+ mutation-fn (partial ops/mutation-fn run-config mutations)
+ crossover-fn (partial ops/crossover-fn run-config mutations)
+
+ ga-state (ga/initialize initial-pop score-fn mutation-fn crossover-fn)]
+
+ (is (= 100 (count initial-pop)) "Should have 100 phenotypes")
+
+ ;; Run 50 iterations
+ (loop [state ga-state
+ i 50]
+ (when (pos? i)
+ (let [evolved (ga/evolve state)]
+ ;; Check for corruption
+ (doseq [p (:pop evolved)]
+ (let [expr-str (str (:expr p))]
+ (when (or (.contains expr-str "Function(")
+ (.contains expr-str "Hold("))
+ (log/debug "CORRUPTION at iter" (- 50 i) "in pop:" expr-str)
+ (throw (ex-info "Corruption detected!" {:expr expr-str :iter (- 50 i)})))
+ (is (not (.contains expr-str "Function(")) expr-str)
+ (is (not (.contains expr-str "Hold(")) expr-str)))
+ (recur evolved (dec i)))))
+
+ (is true "Intensive evolution completed without corruption")))))
+
+
+(deftest test-parse-does-not-introduce-function-wrapper
+ (testing "parsed phenotypes should not contain Function( in their expression"
+ (let [formulas ["Sin(x)"
+ "x^2"
+ "0.538165*Sin(x)"
+ "1/2+x"
+ "Cos(x)+Sin(x)/2"]]
+ (doseq [f formulas]
+ (let [p (parse-formula->phenotype f)
+ expr-str (str (:expr p))]
+ (log/debug "Parsed formula" f "=> expr:" expr-str)
+ (is (not (.contains expr-str "Function("))
+ (str "Formula " f " should not have Function( in expr: " expr-str))
+ (is (not (.contains expr-str "Hold("))
+ (str "Formula " f " should not have Hold( in expr: " expr-str)))))))
+
+
+(deftest test-phenotype-evaluation-does-not-corrupt
+ (testing "evaluating a parsed phenotype does not corrupt it"
+ (let [xs [0.0 0.5 1.0 1.5 2.0]
+ xs-exprs (ops-common/doubles->exprs xs)
+ run-args {:input-xs-list (ops-common/exprs->exprs-list xs-exprs)
+ :input-xs-count (count xs)}
+ p (parse-formula->phenotype "Sin(x)")]
+
+ (log/debug "Before eval, expr:" (str (:expr p)))
+
+ ;; Evaluate the phenotype
+ (let [result (closyr.ops.eval/eval-vec-pheno p run-args)]
+ (log/debug "After eval, result:" result)
+ (log/debug "After eval, expr:" (str (:expr p))))
+
+ ;; The phenotype's expr should not be mutated by evaluation
+ (is (not (.contains (str (:expr p)) "Function("))
+ "Expr should not contain Function( after eval")
+ (is (not (.contains (str (:expr p)) "Hold("))
+ "Expr should not contain Hold( after eval"))))
+
+
+(deftest test-score-function-does-not-corrupt-phenotype
+ (testing "scoring a parsed phenotype does not corrupt its expr"
+ (let [xs [0.0 0.5 1.0 1.5 2.0]
+ ys (mapv #(Math/sin %) xs)
+ xs-exprs (ops-common/doubles->exprs xs)
+ run-args {:input-xs-list (ops-common/exprs->exprs-list xs-exprs)
+ :input-xs-count (count xs)
+ :input-xs-vec xs
+ :input-ys-vec ys
+ :input-ys-arr (double-array ys)}
+ run-config {:max-leafs 40}
+ p (parse-formula->phenotype "Sin(x)")]
+
+ (log/debug "Before score, expr:" (str (:expr p)))
+
+ ;; Score the phenotype
+ (let [score (ops/score-fn run-args run-config p)]
+ (log/debug "Score:" score)
+ (log/debug "After score, expr:" (str (:expr p))))
+
+ ;; The phenotype's expr should not be mutated by scoring
+ (is (not (.contains (str (:expr p)) "Function("))
+ "Expr should not contain Function( after scoring")
+ (is (not (.contains (str (:expr p)) "Hold("))
+ "Expr should not contain Hold( after scoring"))))
+
+
+;;; ============================================================================
+;;; Tests - Corrupted Formula Patterns (from real errors)
+;;; ============================================================================
+
+
+(deftest test-corrupted-formula-patterns-are-handled
+ (testing "formulas containing corruption patterns are handled gracefully"
+ ;; These patterns were seen in real errors and should not crash the parser
+ (let [corrupted-formulas ["Hold(Function({x},0.538165<>.6842,0.7895,0.8947,1.0}])"
+ "Function({x}, Sin(x))"
+ "{x} + 1"
+ "<>"
+ "List(1,2,3)"
+ "Hold(x)"]]
+ (doseq [formula corrupted-formulas]
+ ;; These should either parse to nil or parse to something that doesn't crash
+ ;; The key is they shouldn't throw exceptions during parsing
+ (let [result (try
+ (parse-formula->phenotype formula)
+ (catch Exception e
+ (log/debug "Exception parsing corrupted formula:" formula "-" (.getMessage e))
+ :exception))]
+ ;; Parsing corrupted formulas might return nil or a phenotype,
+ ;; but should NOT throw exceptions
+ (is (not= :exception result)
+ (str "Parsing corrupted formula should not throw: " formula)))))))
+
+
+(deftest test-valid-formulas-accepted
+ (testing "normal valid formulas are accepted and parse correctly"
+ (let [valid-formulas ["Sin(x)"
+ "x^2 + 2*x + 1"
+ "0.538165*Sin(x)"
+ "Cos(x) + Sin(x)/2"
+ "Log(1+x)"
+ "Exp(-x^2)"]]
+ (doseq [formula valid-formulas]
+ (let [pheno (parse-formula->phenotype formula)]
+ (is (some? pheno) (str "Valid formula should parse: " formula))
+ (is (= ops-common/sym-x (:sym pheno)) (str "Should have sym-x: " formula))
+ (is (some? (:expr pheno)) (str "Should have expr: " formula)))))))
+
+
+;;; ============================================================================
+;;; Run tests
+;;; ============================================================================
+
+(comment
+ (run-tests))
diff --git a/test/closyr/symbolic_regression_test.clj b/test/closyr/symbolic_regression_test.clj
index 3d0664b4..73710cce 100644
--- a/test/closyr/symbolic_regression_test.clj
+++ b/test/closyr/symbolic_regression_test.clj
@@ -5,85 +5,107 @@
[clojure.test :refer :all]
[closyr.ops :as ops]
[closyr.ops.common :as ops-common]
+ [closyr.ops.eval :as ops-eval]
[closyr.ops.initialize :as ops-init]
[closyr.symbolic-regression :as symreg]
+ [closyr.test-utils :as test-utils]
[closyr.util.spec :as specs]
[malli.core :as m])
(:import
(java.awt
- GraphicsEnvironment)))
+ GraphicsEnvironment)
+ (org.matheclipse.core.interfaces
+ IExpr)))
+(use-fixtures :once test-utils/quiet-logging-fixture)
+
(alter-var-root #'symreg/*is-testing* (constantly true))
(deftest end-iters-if-solution-found-test
(testing "not solved"
(is (=
- (#'symreg/next-iters 10 [-10.0])
- 9)))
+ 9
+ (#'symreg/next-iters 10 [-10.0]))))
(testing "an exact solution"
(is (=
- (#'symreg/next-iters 10 [0.0])
- 0))))
+ 0
+ (#'symreg/next-iters 10 [0.0])))))
(deftest can-run-from-cli-args
(testing "args from CLI are passed along correctly to implementation"
(let [args* (atom nil)]
(binding [ops/*print-top-n* 1]
- (is (=
- (dissoc
- (with-redefs-fn {#'symreg/run-ga-iterations-using-record
- (fn [run-config run-args]
- (reset! args*
- [(dissoc run-config :initial-muts :initial-phenos :input-xs-exprs :input-ys-exprs)
- (dissoc run-args :extended-domain-args :initial-phenos :input-xs-list)])
- {:iters-done 123
- :final-population {:pop []
- :score-fn #()
- :pop-scores []
- :mutation-fn #()
- :crossover-fn #()}
- :next-step :stop})
- #'symreg/config->log-steps (fn [_ _] 200)}
- (fn []
- (symreg/run-app-from-cli-args
- {:iterations 20
- :population 20
- :headless true
- :xs [0 1 2]
- :ys [1 4 19]
- :use-flamechart true
- :max-leafs 20})))
- :final-population)
- {:iters-done 123
- :next-step :stop}))
-
- (is (= @args*
- [{:iters 20
+ (is (= {:iters-done 123
+ :next-step :stop}
+ (dissoc
+ (with-redefs-fn {#'symreg/run-solver-ga-iterations
+ (fn [run-config run-args]
+ (reset! args*
+ [(dissoc run-config :initial-muts :initial-phenos :input-xs-exprs :input-ys-exprs)
+ (dissoc run-args :extended-domain-args :initial-phenos :input-xs-list :input-ys-arr)])
+ {:iters-done 123
+ :final-population {:pop []
+ :score-fn #()
+ :pop-scores []
+ :mutation-fn #()
+ :crossover-fn #()}
+ :next-step :stop})
+ #'symreg/config->log-steps (fn [_ _] 200)}
+ (fn []
+ (symreg/run-app-from-cli-args
+ {:iterations 20
+ :population 20
+ :headless true
+ :xs [0 1 2]
+ :ys [1 4 19]
+ :use-flamechart true
+ :max-leafs 20
+ :seed 123})))
+ :final-population)))
+
+ (is (= [{:iters 20
:log-steps 200
:max-leafs 20
:use-gui? false
+ :random-seed 123
+ :adaptive-mode nil
+ :quiet-logs nil
+ :use-eval-cache nil
+ :scoring-method :mae-max
:use-flamechart true}
- {:input-iters 20
- :input-phenos-count nil
- :input-xs-count 3
- :input-xs-vec [0.0 1.0 2.0]
- :input-ys-vec [1.0 4.0 19.0]
- :max-leafs 20}])))))
+ {:input-iters 20
+ :input-phenos-count nil
+ :random-seed 123
+ :adaptive-mode nil
+ :quiet-logs nil
+ :use-eval-cache nil
+ :simplicity-bias nil
+ :scoring-method nil
+ :input-xs-count 3
+ :input-xs-vec [0.0 1.0 2.0]
+ :input-ys-vec [1.0 4.0 19.0]
+ :max-leafs 20
+ :mutations-blacklist nil
+ :log-steps nil}]
+ @args*)
+ "Arguments should be consistent with inputs"))))
(testing "args from CLI are passed along correctly to implementation, and when none are passed we use defaults"
(let [args* (atom nil)]
(binding [ops/*print-top-n* 1]
(is (=
+ {:iters-done 123
+ :next-step :stop}
(dissoc
- (with-redefs-fn {#'symreg/run-ga-iterations-using-record
+ (with-redefs-fn {#'symreg/run-solver-ga-iterations
(fn [run-config run-args]
(reset! args*
[(dissoc run-config :initial-muts :initial-phenos :input-xs-exprs :input-ys-exprs)
- (dissoc run-args :extended-domain-args :initial-phenos :input-xs-list)])
+ (dissoc run-args :extended-domain-args :initial-phenos :input-xs-list :input-ys-arr)])
{:iters-done 123
:final-population {:pop []
:score-fn #()
@@ -97,22 +119,34 @@
{:population 30
:iterations 20
:headless true})))
- :final-population)
- {:iters-done 123
- :next-step :stop}))
+ :final-population)))
- (is (= @args*
- [{:iters 20
+ (is (= [{:iters 20
:log-steps 200
:max-leafs 40
:use-gui? false
+ :random-seed nil
+ :adaptive-mode nil
+ :quiet-logs nil
+ :use-eval-cache nil
+ :scoring-method :mae-max
:use-flamechart nil}
- {:input-iters 20
- :input-phenos-count nil
- :input-xs-count 50
- :input-xs-vec [0.0 0.20943951023931953 0.41887902047863906 0.6283185307179586 0.8377580409572781 1.0471975511965976 1.2566370614359172 1.4660765716752369 1.6755160819145563 1.8849555921538759 2.0943951023931953 2.3038346126325147 2.5132741228718345 2.7227136331111543 2.9321531433504737 3.141592653589793 3.3510321638291125 3.560471674068432 3.7699111843077517 3.979350694547071 4.1887902047863905 4.39822971502571 4.607669225265029 4.81710873550435 5.026548245743669 5.235987755982989 5.445427266222309 5.654866776461628 5.8643062867009474 6.073745796940266 6.283185307179586 6.492624817418906 6.702064327658225 6.911503837897546 7.120943348136864 7.3303828583761845 7.5398223686155035 7.749261878854823 7.958701389094142 8.168140899333462 8.377580409572781 8.587019919812102 8.79645943005142 9.00589894029074 9.215338450530059 9.42477796076938 9.6342174710087 9.843656981248019 10.053096491487338 10.262536001726657]
- :input-ys-vec [0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0]
- :max-leafs nil}]))))))
+ {:input-iters 20
+ :input-phenos-count nil
+ :random-seed nil
+ :adaptive-mode nil
+ :quiet-logs nil
+ :use-eval-cache nil
+ :scoring-method nil
+ :simplicity-bias nil
+ :input-xs-count 50
+ :input-xs-vec [0.0 0.20943951023931953 0.41887902047863906 0.6283185307179586 0.8377580409572781 1.0471975511965976 1.2566370614359172 1.4660765716752369 1.6755160819145563 1.8849555921538759 2.0943951023931953 2.3038346126325147 2.5132741228718345 2.7227136331111543 2.9321531433504737 3.141592653589793 3.3510321638291125 3.560471674068432 3.7699111843077517 3.979350694547071 4.1887902047863905 4.39822971502571 4.607669225265029 4.81710873550435 5.026548245743669 5.235987755982989 5.445427266222309 5.654866776461628 5.8643062867009474 6.073745796940266 6.283185307179586 6.492624817418906 6.702064327658225 6.911503837897546 7.120943348136864 7.3303828583761845 7.5398223686155035 7.749261878854823 7.958701389094142 8.168140899333462 8.377580409572781 8.587019919812102 8.79645943005142 9.00589894029074 9.215338450530059 9.42477796076938 9.6342174710087 9.843656981248019 10.053096491487338 10.262536001726657]
+ :input-ys-vec [0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0]
+ :max-leafs nil
+ :mutations-blacklist nil
+ :log-steps nil}]
+ @args*)
+ "Arguments should be consistent with inputs")))))
(deftest can-run-experiment
@@ -123,32 +157,40 @@
(:final-population
(with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
(fn []
- (symreg/run-app-without-gui [1 2 3] [6 12 99]))))))
+ (symreg/run-find-formula
+ {:initial-phenos (ops-init/initial-phenotypes 100)
+ :initial-muts (ops-init/initial-mutations)
+ :iters 20
+ :use-gui? false
+ :use-flamechart false
+ :input-xs-exprs (ops-common/doubles->exprs [1 2 3])
+ :input-ys-exprs (ops-common/doubles->exprs [6 12 99])}))))))
100)))
(testing "with gui launcher"
- (let [res (with-redefs-fn {#'symreg/run-solver (fn [args] args)}
+ (let [res (with-redefs-fn {#'symreg/run-find-formula (fn [args] args)}
(fn []
(#'symreg/run-app-with-gui)))]
- (is (= (dissoc res :initial-phenos :initial-muts :input-xs-exprs :input-ys-exprs)
- {:iters 100
+ (is (= {:iters 100
:max-leafs 40
:use-flamechart false
- :use-gui? true}))
- (is (= (count (:initial-phenos res))
- 50))
- (is (= (count (:initial-muts res))
- 96))
- (is (= (count (:input-xs-exprs res))
- 50))
- (is (= (count (:input-ys-exprs res))
- 50))))
+ :use-gui? true}
+ (dissoc res :initial-phenos :initial-muts :input-xs-exprs :input-ys-exprs)))
+ (is (= 50
+ (count (:initial-phenos res))))
+ (is (= 96
+ (count (:initial-muts res))))
+ (is (= 50
+ (count (:input-xs-exprs res))))
+ (is (= 50
+ (count (:input-ys-exprs res))))))
(testing "with provided data"
+ (reset! symreg/sim-input-args* {})
(with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
(fn []
(let [{:keys [final-population next-step iters-done]}
- (symreg/run-solver
+ (symreg/run-find-formula
{:input-phenos-count 100
:initial-muts (ops-init/initial-mutations)
:iters 5
@@ -163,50 +205,79 @@
(/ i 10.0)
(Math/cos (* Math/PI (/ i 15.0))))))
ops-common/doubles->exprs)})]
- (is (= (count (:pop final-population))
- 100))
+ (is (= 100
+ (count (:pop final-population))))
- (is (= iters-done
- 5))
+ (is (= 5
+ iters-done))
- (is (= (set (keys @symreg/sim-input-args*))
- #{:input-xs-exprs
+ (is (= #{:input-xs-exprs
:input-xs-vec
- :input-ys-vec}))
-
- (reset! symreg/sim-input-args* {})))))
+ :input-ys-vec}
+ (set (keys @symreg/sim-input-args*))))))))
- (testing "with provided data using record"
+ (testing "with provided data and random seed"
+ (reset! symreg/sim-input-args* {})
(with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
(fn []
(let [{:keys [final-population next-step iters-done]}
- (symreg/solve
- (symreg/map->SymbolicRegressionSolver
- {:input-phenos-count 100
- :initial-muts (ops-init/initial-mutations)
- :iters 5
- :use-gui? false
- :input-xs-exprs (->> (range 50)
- (map (fn [i] (* Math/PI (/ i 15.0))))
- ops-common/doubles->exprs)
- :input-ys-exprs (->> (range 50)
- (map (fn [i]
- (+ 2.0
- (/ i 10.0)
- (Math/cos (* Math/PI (/ i 15.0))))))
- ops-common/doubles->exprs)}))]
- (is (= (count (:pop final-population))
- 100))
-
- (is (= iters-done
- 5))
-
- (is (= (set (keys @symreg/sim-input-args*))
- #{:input-xs-exprs
+ (symreg/run-find-formula
+ {:input-phenos-count 100
+ :initial-muts (ops-init/initial-mutations)
+ :iters 5
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 1234
+ :input-xs-exprs (->> (range 50)
+ (map (fn [i] (* Math/PI (/ i 15.0))))
+ ops-common/doubles->exprs)
+ :input-ys-exprs (->> (range 50)
+ (map (fn [i]
+ (+ 2.0
+ (/ i 10.0)
+ (Math/cos (* Math/PI (/ i 15.0))))))
+ ops-common/doubles->exprs)})]
+ (is (= 100
+ (count (:pop final-population))))
+
+ (is (= 5
+ iters-done))
+
+ (is (= #{:input-xs-exprs
:input-xs-vec
- :input-ys-vec}))
+ :input-ys-vec}
+ (set (keys @symreg/sim-input-args*))))))))
- (reset! symreg/sim-input-args* {})))))))
+ (testing "with provided data as map"
+ (reset! symreg/sim-input-args* {})
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (let [{:keys [final-population next-step iters-done]}
+ (symreg/run-find-formula
+ {:input-phenos-count 100
+ :initial-muts (ops-init/initial-mutations)
+ :iters 5
+ :use-gui? false
+ :use-flamechart false
+ :input-xs-exprs (->> (range 50)
+ (map (fn [i] (* Math/PI (/ i 15.0))))
+ ops-common/doubles->exprs)
+ :input-ys-exprs (->> (range 50)
+ (map (fn [i]
+ (+ 2.0
+ (/ i 10.0)
+ (Math/cos (* Math/PI (/ i 15.0))))))
+ ops-common/doubles->exprs)})]
+ (is (= 100
+ (count (:pop final-population))))
+
+ (is (= 5
+ iters-done))
+
+ (is (= #{:input-xs-exprs
+ :input-xs-vec
+ :input-ys-vec}
+ (set (keys @symreg/sim-input-args*))))))))))
#_(deftest can-run-experiment-gui:start-stop
@@ -227,22 +298,289 @@
(is (put! symreg/*sim->gui-chan* :next))
true)]
- (symreg/run-solver
+ (symreg/run-find-formula
{:initial-phenos (ops-init/initial-phenotypes 20)
:initial-muts (ops-init/initial-mutations)
:input-xs-exprs symreg/example-input-xs-exprs
:input-ys-exprs symreg/example-input-ys-exprs
:iters 20
- :use-gui? true})
+ :use-gui? true
+ :use-flamechart false})
(is (= (log-steps (fn [_ _] 10)}
+ (fn []
+ (let [{:keys [final-population next-step iters-done] :as resp}
+ (symreg/run-find-formula
+ {:input-phenos-count 10
+ :initial-muts (ops-init/initial-mutations)
+ :iters 5
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 123
+ :input-xs-exprs (->> (range 50)
+ (map (fn [i] (* Math/PI (/ i 15.0))))
+ ops-common/doubles->exprs)
+ :input-ys-exprs (->> (range 50)
+ (map (fn [i]
+ (+ 2.0
+ (/ i 10.0)
+ (Math/cos (* Math/PI (/ i 15.0))))))
+ ops-common/doubles->exprs)})]
+
+ (is (=
+ '(-2086020.9864992178
+ -1040014.0760937533
+ -243.28664816600795
+ -190.5004535058019
+ -12.807688931991098)
+ (sort (:pop-scores (:final-population resp)))))
+
+ (is (= 10
+ (count (:pop final-population))))
+
+ (is (= 5
+ iters-done))
+
+ (is (= #{:input-xs-exprs
+ :input-xs-vec
+ :input-ys-vec}
+ (set (keys @symreg/sim-input-args*)))))))))
+
+
+(deftest deterministic-experiments-scoring-methods
+ (let [run-config {:input-phenos-count 10
+ :initial-muts (ops-init/initial-mutations)
+ :iters 5
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 456
+ :input-xs-exprs (->> (range 20)
+ (map (fn [i] (* 0.5 i)))
+ ops-common/doubles->exprs)
+ :input-ys-exprs (->> (range 20)
+ (map (fn [i] (+ (* 2 i) 3)))
+ ops-common/doubles->exprs)}]
+
+ (testing "mae-max scoring method (default)"
+ (reset! symreg/sim-input-args* {})
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (binding [ops/*scoring-method* :mae-max]
+ (let [{:keys [final-population iters-done] :as resp}
+ (symreg/run-find-formula run-config)
+ sorted-scores (sort (:pop-scores final-population))]
+ ;; MAE scores are negative (closer to 0 is better)
+ (is (every? neg? sorted-scores))
+ (is (= 10 (count (:pop final-population))))
+ (is (= 5 iters-done))
+ ;; Best score should be better (less negative) than worst
+ (is (> (last sorted-scores) (first sorted-scores))))))))
+
+ (testing "log-cosh scoring method"
+ (reset! symreg/sim-input-args* {})
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (binding [ops/*scoring-method* :log-cosh]
+ (let [{:keys [final-population iters-done] :as resp}
+ (symreg/run-find-formula run-config)
+ sorted-scores (sort (:pop-scores final-population))]
+ ;; Log-cosh scores are negative (closer to 0 is better)
+ (is (every? neg? sorted-scores))
+ (is (= 10 (count (:pop final-population))))
+ (is (= 5 iters-done))
+ ;; Best score should be better (less negative) than worst
+ (is (> (last sorted-scores) (first sorted-scores))))))))
+
+ (testing "r-squared scoring method"
+ (reset! symreg/sim-input-args* {})
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (binding [ops/*scoring-method* :r-squared]
+ (let [{:keys [final-population iters-done] :as resp}
+ (symreg/run-find-formula run-config)
+ sorted-scores (sort (:pop-scores final-population))]
+ ;; R² scores can be negative (bad) to 1.0 (perfect)
+ ;; Best scores should be closer to 1.0
+ (is (= 10 (count (:pop final-population))))
+ (is (= 5 iters-done))
+ ;; Best score should be better (higher, closer to 1) than worst
+ (is (> (last sorted-scores) (first sorted-scores)))
+ ;; R² for good fits will still be negative
+ (is (neg? (last sorted-scores))))))))
+
+ (testing "different scoring methods produce different score ranges"
+ (reset! symreg/sim-input-args* {})
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (let [mae-result (binding [ops/*scoring-method* :mae-max]
+ (symreg/run-find-formula run-config))
+ log-cosh-result (binding [ops/*scoring-method* :log-cosh]
+ (symreg/run-find-formula run-config))
+ r2-result (binding [ops/*scoring-method* :r-squared]
+ (symreg/run-find-formula run-config))
+ mae-best (apply max (:pop-scores (:final-population mae-result)))
+ log-cosh-best (apply max (:pop-scores (:final-population log-cosh-result)))
+ r2-best (apply max (:pop-scores (:final-population r2-result)))]
+ ;; MAE and log-cosh best scores are negative (less negative = better)
+ (is (neg? mae-best))
+ (is (neg? log-cosh-best))
+ ;; R² best score should still be negative for reasonable fits
+ (is (neg? r2-best))
+ ;; R² is bounded above by 1.0
+ (is (<= r2-best 1.0))))))))
+
+
+(deftest cross-method-scoring-comparison
+ (testing "compare solutions from different scoring methods using all scoring metrics"
+ (let [;; Simple quadratic data: y = x^2
+ xs-vec (mapv double (range 1 6))
+ ys-vec (mapv (fn [x] (+ (* x x 0.5) x 1)) xs-vec) ;; 0.5 * x^2 + x + 1
+ ys-arr (double-array ys-vec)
+
+ run-config {:input-phenos-count 15
+ :initial-muts (ops-init/initial-mutations)
+ :iters 8
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 789
+ :input-xs-exprs (ops-common/doubles->exprs xs-vec)
+ :input-ys-exprs (ops-common/doubles->exprs ys-vec)}
+
+ ;; Helper to evaluate a phenotype under a specific scoring method
+ score-pheno-with-method (fn [pheno method]
+ (let [f-of-xs (ops-eval/eval-vec-pheno
+ pheno
+ {:input-xs-list (ops-common/exprs->exprs-list
+ (ops-common/doubles->exprs xs-vec))
+ :input-xs-count (count xs-vec)})]
+ (when f-of-xs
+ (#'ops/compute-score-from-actuals-and-expecteds
+ pheno f-of-xs ys-vec
+ (.leafCount ^IExpr (:expr pheno))
+ ys-arr
+ method))))
+
+ ;; Run with each scoring method and get best solution
+ _ (reset! symreg/sim-input-args* {})
+ mae-result (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (symreg/run-find-formula (assoc run-config :scoring-method :mae-max))))
+ mae-best (first (sort-by :score > (:pop (:final-population mae-result))))
+
+ _ (reset! symreg/sim-input-args* {})
+ log-cosh-result (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (symreg/run-find-formula (assoc run-config :scoring-method :log-cosh))))
+ log-cosh-best (first (sort-by :score > (:pop (:final-population log-cosh-result))))
+
+ _ (reset! symreg/sim-input-args* {})
+ r2-result (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (symreg/run-find-formula (assoc run-config :scoring-method :r-squared))))
+ r2-best (first (sort-by :score > (:pop (:final-population r2-result))))
+
+ ;; Score each best solution under all three methods
+ mae-best-scores {:mae-max (score-pheno-with-method mae-best :mae-max)
+ :log-cosh (score-pheno-with-method mae-best :log-cosh)
+ :r-squared (score-pheno-with-method mae-best :r-squared)}
+ log-cosh-best-scores {:mae-max (score-pheno-with-method log-cosh-best :mae-max)
+ :log-cosh (score-pheno-with-method log-cosh-best :log-cosh)
+ :r-squared (score-pheno-with-method log-cosh-best :r-squared)}
+ r2-best-scores {:mae-max (score-pheno-with-method r2-best :mae-max)
+ :log-cosh (score-pheno-with-method r2-best :log-cosh)
+ :r-squared (score-pheno-with-method r2-best :r-squared)}]
+
+ ;; Log results for inspection
+ ;(println "\n=== Cross-Method Scoring Comparison ===")
+ ;(println "MAE-trained best formula:" (str (:expr mae-best)))
+ ;(println " scored as MAE:" (:mae-max mae-best-scores)
+ ; "log-cosh:" (:log-cosh mae-best-scores)
+ ; "R²:" (:r-squared mae-best-scores))
+ ;
+ ;(println "Log-cosh-trained best formula:" (str (:expr log-cosh-best)))
+ ;(println " scored as MAE:" (:mae-max log-cosh-best-scores)
+ ; "log-cosh:" (:log-cosh log-cosh-best-scores)
+ ; "R²:" (:r-squared log-cosh-best-scores))
+ ;
+ ;(println "R²-trained best formula:" (str (:expr r2-best)))
+ ;(println " scored as MAE:" (:mae-max r2-best-scores)
+ ; "log-cosh:" (:log-cosh r2-best-scores)
+ ; "R²:" (:r-squared r2-best-scores))
+ ;(println "========================================\n")
+
+ ;; Basic assertions - all scores should be numeric and negative (closer to 0 = better)
+ (is (number? (:mae-max mae-best-scores)))
+ (is (number? (:log-cosh mae-best-scores)))
+ (is (number? (:r-squared mae-best-scores)))
+
+ ;; Each solution should score best (or very well) under its own training method
+ ;; This is a sanity check that the scoring methods are being applied correctly
+ (is (or (neg? (:mae-max mae-best-scores)) (zero? (:mae-max mae-best-scores))))
+ (is (or (neg? (:log-cosh log-cosh-best-scores)) (zero? (:log-cosh log-cosh-best-scores))))
+ (is (or (neg? (:r-squared r2-best-scores)) (zero? (:r-squared r2-best-scores))))
+
+ ;; R² scores should be bounded above by 0 (since we shifted by -1)
+ (is (<= (:r-squared mae-best-scores) 0))
+ (is (<= (:r-squared log-cosh-best-scores) 0))
+ (is (<= (:r-squared r2-best-scores) 0)))))
+
+
+(deftest simplicity-bias-in-run-find-formula
+ (let [run-config {:input-phenos-count 10
+ :initial-muts (ops-init/initial-mutations)
+ :iters 3
+ :use-gui? false
+ :use-flamechart false
+ :random-seed 999
+ :input-xs-exprs (->> (range 10)
+ (map (fn [i] (* 0.5 i)))
+ ops-common/doubles->exprs)
+ :input-ys-exprs (->> (range 10)
+ (map (fn [i] (+ (* 2 i) 3)))
+ ops-common/doubles->exprs)}]
+
+ (testing "simplicity-bias can be passed to run-find-formula"
+ (reset! symreg/sim-input-args* {})
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ ;; Should not throw with simplicity-bias option
+ (let [{:keys [final-population iters-done]}
+ (symreg/run-find-formula (assoc run-config :simplicity-bias :strong))]
+ (is (= 10 (count (:pop final-population))))
+ (is (= 3 iters-done))))))
+
+ (testing "different simplicity-bias levels produce different score distributions"
+ (reset! symreg/sim-input-args* {})
+ (with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 10)}
+ (fn []
+ (let [result-none (symreg/run-find-formula (assoc run-config :simplicity-bias :none))
+ result-strong (symreg/run-find-formula (assoc run-config :simplicity-bias :strong))
+ scores-none (:pop-scores (:final-population result-none))
+ scores-strong (:pop-scores (:final-population result-strong))]
+ ;; With same random seed and inputs, :strong bias should have lower (more negative)
+ ;; scores due to the larger complexity penalty
+ ;; At minimum, both should complete without errors and have some population
+ (is (pos? (count scores-none)))
+ (is (pos? (count scores-strong)))
+ ;; Best scores (max) should be negative
+ (is (neg? (apply max scores-none)))
+ (is (neg? (apply max scores-strong)))))))))
+
+
(deftest can-run-experiment-gui:start-restart-stop
(when (not (GraphicsEnvironment/isHeadless))
(binding [ops/*print-top-n* 1]
(testing "gui can start and restart experiments; NOTE: do not run this while in headless mode, eg on CI"
+ (reset! symreg/sim-input-args* {})
+ ;; Verify initial state before launching async processes
+ (is (= (set (keys @symreg/sim-input-args*)) #{}))
(with-redefs-fn {#'symreg/config->log-steps (fn [_ _] 500)}
(fn []
(let [control-process
@@ -256,9 +594,6 @@
:input-iters 200
:input-phenos-count 500}))
- (is (= (set (keys @symreg/sim-input-args*))
- #{:input-xs-vec :input-ys-vec}))
-
(gui-chan* :next))
true)]
- (symreg/run-solver
+ (symreg/run-find-formula
{:initial-phenos (ops-init/initial-phenotypes 20)
:initial-muts (ops-init/initial-mutations)
:input-xs-exprs symreg/example-input-xs-exprs
:input-ys-exprs symreg/example-input-ys-exprs
:iters 20
- :use-gui? true})
+ :use-gui? true
+ :use-flamechart false})
(is (= (log-steps {:iters 100000
:initial-phenos (vec (repeat 10 0))}
- {:input-xs-count 10})
+ {:input-xs-count 10})
25))
(is (=
(#'symreg/config->log-steps {:iters 1000
:initial-phenos (vec (repeat 10000 0))}
- {:input-xs-count 150})
+ {:input-xs-count 150})
2))
(is (=
(#'symreg/config->log-steps {:iters 10
:initial-phenos (vec (repeat 10 0))}
- {:input-xs-count 10})
+ {:input-xs-count 10})
1))))
@@ -368,8 +711,17 @@
:initial-phenos
:input-iters
:input-phenos-count
+ :random-seed
+ :quiet-logs
+ :adaptive-mode
+ :use-eval-cache
+ :scoring-method
+ :simplicity-bias
:input-xs-count
:input-xs-list
:input-xs-vec
+ :input-ys-arr
:input-ys-vec
- :max-leafs}))))
+ :max-leafs
+ :mutations-blacklist
+ :log-steps}))))
diff --git a/test/closyr/test_utils.clj b/test/closyr/test_utils.clj
new file mode 100644
index 00000000..b63f40fe
--- /dev/null
+++ b/test/closyr/test_utils.clj
@@ -0,0 +1,12 @@
+(ns closyr.test-utils
+ "Test utilities and fixtures for quieter logging during tests"
+ (:require
+ [closyr.util.log :as log]))
+
+
+(defn quiet-logging-fixture
+ "Test fixture that sets log level to WARN during tests.
+ Use with: (use-fixtures :once quiet-logging-fixture)"
+ [f]
+ (log/set-log-level! :warn)
+ (f))
diff --git a/test/closyr/util_prng_test.clj b/test/closyr/util_prng_test.clj
index 05b767dd..f6113ca9 100644
--- a/test/closyr/util_prng_test.clj
+++ b/test/closyr/util_prng_test.clj
@@ -8,7 +8,7 @@
[seed n]
(prng/set-random-seed! seed)
(let [r1 (prng/rand-int n) r2 (prng/rand-int n)]
- (println "Seed: " seed " n: " n
+ #_(println "Seed: " seed " n: " n
;; https://github.com/trystan/random-seed/issues/3
;; odd that the first value is so similar for different seeds:
" rand-int: " r1
@@ -23,3 +23,44 @@
(testing "can sample rand ints"
(is (= (mapv #(test-rand-int-gen % 50) [1 5 10 20 50 75 100 1000 10000 100000])
[[36 5] [36 8] [36 22] [36 30] [36 29] [36 46] [36 36] [35 12] [44 40] [26 29]]))))
+
+
+(deftest test-random-uuid-deterministic
+ (testing "random-uuid is deterministic with seed"
+ (prng/set-random-seed! 12345)
+ (let [uuid1 (prng/random-uuid)]
+ (prng/set-random-seed! 12345)
+ (let [uuid2 (prng/random-uuid)]
+ (is (= uuid1 uuid2)
+ "Same seed should produce same UUID")))))
+
+
+(deftest test-random-uuid-different-seeds
+ (testing "random-uuid produces different results with different seeds"
+ (prng/set-random-seed! 111)
+ (let [uuid1 (prng/random-uuid)]
+ (prng/set-random-seed! 222)
+ (let [uuid2 (prng/random-uuid)]
+ (is (not= uuid1 uuid2)
+ "Different seeds should produce different UUIDs")))))
+
+
+(deftest test-shuffle-deterministic
+ (testing "shuffle is deterministic with seed"
+ (prng/set-random-seed! 42)
+ (let [result1 (prng/shuffle [1 2 3 4 5 6 7 8 9 10])]
+ (prng/set-random-seed! 42)
+ (let [result2 (prng/shuffle [1 2 3 4 5 6 7 8 9 10])]
+ (is (= result1 result2)
+ "Same seed should produce same shuffle order")))))
+
+
+(deftest test-rand-nth-deterministic
+ (testing "rand-nth is deterministic with seed"
+ (let [coll [:a :b :c :d :e :f :g :h :i :j]]
+ (prng/set-random-seed! 999)
+ (let [picks1 (vec (repeatedly 5 #(prng/rand-nth coll)))]
+ (prng/set-random-seed! 999)
+ (let [picks2 (vec (repeatedly 5 #(prng/rand-nth coll)))]
+ (is (= picks1 picks2)
+ "Same seed should produce same rand-nth sequence"))))))
diff --git a/test/closyr/util_spec_test.clj b/test/closyr/util_spec_test.clj
index 454ce815..c2f332e5 100644
--- a/test/closyr/util_spec_test.clj
+++ b/test/closyr/util_spec_test.clj
@@ -26,6 +26,7 @@
{:max-leafs 20,
:input-iters 10000,
:input-phenos-count 50000,
+ :random-seed -1,
:new-state :start,
:input-data-x
[0.0
@@ -188,7 +189,7 @@
(is (=
(reduce + 0 (map (fn [[k v]] (count v)) ss))
;; the number of total defns which have malli/schema metadata in entire src:
- 17))))))
+ 14))))))
#_(deftest decode-test
diff --git a/test/closyr/web_test.clj b/test/closyr/web_test.clj
new file mode 100644
index 00000000..8afad809
--- /dev/null
+++ b/test/closyr/web_test.clj
@@ -0,0 +1,345 @@
+(ns closyr.web-test
+ "Tests for the HTTP server and API endpoints."
+ (:require
+ [cheshire.core :as json]
+ [clojure.test :refer :all]
+ [closyr.test-utils :as test-utils]
+ [closyr.web.handlers.api :as api]
+ [closyr.web.middleware :as mw]
+ [closyr.web.routes :as routes]
+ [closyr.web.server :as server])
+ (:import
+ (java.io ByteArrayInputStream)))
+
+
+(use-fixtures :once test-utils/quiet-logging-fixture)
+
+
+;; ============================================================================
+;; Helper functions
+;; ============================================================================
+
+(defn- json-body
+ "Create a JSON body as an InputStream from a map."
+ [data]
+ (ByteArrayInputStream. (.getBytes (json/encode data) "UTF-8")))
+
+
+(defn- parse-json-body
+ "Parse JSON response body."
+ [response]
+ (when (:body response)
+ (json/parse-string (:body response) true)))
+
+
+(defn- make-request
+ "Helper to create a ring request map."
+ [method uri & {:keys [body headers params]}]
+ (cond-> {:request-method method
+ :uri uri}
+ body (assoc :body (json-body body))
+ headers (assoc :headers (merge {"content-type" "application/json"} headers))
+ body (assoc :headers (merge {"content-type" "application/json"} headers))
+ params (assoc :path-params params)))
+
+
+;; ============================================================================
+;; Server lifecycle tests
+;; ============================================================================
+
+(deftest test-server-not-running-initially
+ (testing "Server is not running when not started"
+ ;; Make sure server is stopped first
+ (server/stop!)
+ (is (not (server/running?)))))
+
+
+(deftest test-server-start-stop
+ (testing "Server can start and stop"
+ (try
+ (let [srv (server/start! {:port 3333})]
+ (is (some? srv))
+ (is (server/running?))
+ (server/stop!)
+ (is (not (server/running?))))
+ (finally
+ (server/stop!)))))
+
+
+(deftest test-server-restart
+ (testing "Starting server while running restarts it"
+ (try
+ (server/start! {:port 3334})
+ (is (server/running?))
+ ;; Start again on different port
+ (server/start! {:port 3335})
+ (is (server/running?))
+ (finally
+ (server/stop!)))))
+
+
+;; ============================================================================
+;; Routes and app handler tests
+;; ============================================================================
+
+(deftest test-routes-defined
+ (testing "Routes are defined"
+ (is (vector? routes/routes))
+ (is (pos? (count routes/routes)))))
+
+
+(deftest test-app-handler-exists
+ (testing "App handler is a function"
+ (is (fn? routes/app))))
+
+
+(deftest test-404-for-unknown-route
+ (testing "Unknown routes return 404"
+ (let [response (routes/app {:request-method :get
+ :uri "/unknown-route-xyz"})]
+ (is (= 404 (:status response))))))
+
+
+;; ============================================================================
+;; API: datasets endpoint tests
+;; ============================================================================
+
+(deftest test-datasets-endpoint
+ (testing "GET /api/datasets returns dataset list"
+ (let [response (api/datasets {})]
+ (is (= 200 (:status response)))
+ (is (= "application/json" (get-in response [:headers "Content-Type"])))
+ (let [body (parse-json-body response)]
+ (is (contains? body :datasets))
+ (is (vector? (:datasets body)))
+ (is (pos? (count (:datasets body))))))))
+
+
+(deftest test-datasets-have-required-fields
+ (testing "Datasets have required fields"
+ (let [response (api/datasets {})
+ body (parse-json-body response)
+ datasets (:datasets body)]
+ (doseq [ds datasets]
+ (is (contains? ds :id) (str "Dataset missing :id: " ds))
+ (is (contains? ds :name) (str "Dataset missing :name: " ds))
+ (is (contains? ds :xs) (str "Dataset missing :xs: " ds))
+ (is (contains? ds :ys) (str "Dataset missing :ys: " ds))))))
+
+
+(deftest test-datasets-include-known-datasets
+ (testing "Known datasets are included"
+ (let [response (api/datasets {})
+ body (parse-json-body response)
+ ids (set (map :id (:datasets body)))]
+ (is (contains? ids "h-line"))
+ (is (contains? ids "nguyen4"))
+ (is (contains? ids "nguyen5"))
+ (is (contains? ids "feynman-lorentz"))
+ (is (contains? ids "feynman-wave"))
+ (is (contains? ids "primes-100")))))
+
+
+;; ============================================================================
+;; API: CSV upload endpoint tests
+;; ============================================================================
+
+(deftest test-upload-csv-basic
+ (testing "CSV upload parses simple data"
+ (let [response (api/upload-csv {:body-params {:content "1,2\n3,4\n5,6"}})]
+ (is (= 200 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (= [1.0 3.0 5.0] (:xs body)))
+ (is (= [2.0 4.0 6.0] (:ys body)))
+ (is (= 3 (:rowCount body)))))))
+
+
+(deftest test-upload-csv-with-headers
+ (testing "CSV upload handles headers"
+ (let [response (api/upload-csv {:body-params {:content "x,y\n1,1\n2,4\n3,9"}})]
+ (is (= 200 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (= [1.0 2.0 3.0] (:xs body)))
+ (is (= [1.0 4.0 9.0] (:ys body)))
+ (is (= 3 (:rowCount body)))))))
+
+
+(deftest test-upload-csv-missing-content
+ (testing "CSV upload fails without content"
+ (let [response (api/upload-csv {:body-params {}})]
+ (is (= 400 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :error))))))
+
+
+(deftest test-upload-csv-invalid-data
+ (testing "CSV upload fails with invalid data"
+ (let [response (api/upload-csv {:body-params {:content "not,valid\ncsv,data"}})]
+ (is (= 400 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :error))))))
+
+
+;; ============================================================================
+;; API: solve endpoint tests
+;; ============================================================================
+
+(deftest test-solve-missing-params
+ (testing "Solve fails without xs/ys"
+ (let [response (api/solve {:body-params {}})]
+ (is (= 400 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :error))))))
+
+
+(deftest test-solve-missing-xs
+ (testing "Solve fails without xs"
+ (let [response (api/solve {:body-params {:ys [1 2 3]}})]
+ (is (= 400 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :error))))))
+
+
+(deftest test-solve-missing-ys
+ (testing "Solve fails without ys"
+ (let [response (api/solve {:body-params {:xs [1 2 3]}})]
+ (is (= 400 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :error))))))
+
+
+(deftest test-solve-returns-job-id
+ (testing "Solve returns job ID and events URL"
+ (let [response (api/solve {:body-params {:xs [1 2 3 4 5]
+ :ys [1 4 9 16 25]
+ :config {:iterations 1
+ :population 5}}})]
+ (is (= 202 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :jobId))
+ (is (contains? body :eventsUrl))
+ (is (string? (:jobId body)))
+ (is (.contains ^String (:eventsUrl body) (:jobId body)))))))
+
+
+;; ============================================================================
+;; API: job status endpoint tests
+;; ============================================================================
+
+(deftest test-get-job-not-found
+ (testing "GET job returns 404 for unknown job"
+ (let [response (api/get-job {:path-params {:id "nonexistent-job-id"}})]
+ (is (= 404 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :error))))))
+
+
+(deftest test-get-job-found
+ (testing "GET job returns job status"
+ ;; First create a job
+ (let [solve-response (api/solve {:body-params {:xs [1 2 3]
+ :ys [2 4 6]
+ :config {:iterations 1
+ :population 5}}})
+ solve-body (parse-json-body solve-response)
+ job-id (:jobId solve-body)
+ ;; Now get the job
+ response (api/get-job {:path-params {:id job-id}})]
+ (is (= 200 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :status))))))
+
+
+;; ============================================================================
+;; API: stop/pause/resume endpoint tests
+;; ============================================================================
+
+(deftest test-stop-job-not-found
+ (testing "Stop returns 404 for unknown job"
+ (let [response (api/stop-job {:path-params {:id "nonexistent-id"}})]
+ (is (= 404 (:status response))))))
+
+
+(deftest test-pause-job-not-found
+ (testing "Pause returns 404 for unknown job"
+ (let [response (api/pause-job {:path-params {:id "nonexistent-id"}})]
+ (is (= 404 (:status response))))))
+
+
+(deftest test-resume-job-not-found
+ (testing "Resume returns 404 for unknown job"
+ (let [response (api/resume-job {:path-params {:id "nonexistent-id"}})]
+ (is (= 404 (:status response))))))
+
+
+;; ============================================================================
+;; Middleware tests
+;; ============================================================================
+
+(deftest test-wrap-json-body-parses-json
+ (testing "JSON body middleware parses JSON"
+ (let [handler (fn [req] {:status 200 :body (:body-params req)})
+ wrapped (mw/wrap-json-body handler)
+ request {:headers {"content-type" "application/json"}
+ :body (json-body {:foo "bar" :num 42})}
+ response (wrapped request)]
+ (is (= {:foo "bar" :num 42} (:body response))))))
+
+
+(deftest test-wrap-json-body-handles-empty
+ (testing "JSON body middleware handles empty body"
+ (let [handler (fn [req] {:status 200 :body (:body-params req)})
+ wrapped (mw/wrap-json-body handler)
+ request {:headers {"content-type" "text/plain"}
+ :body nil}
+ response (wrapped request)]
+ (is (= 200 (:status response))))))
+
+
+(deftest test-wrap-json-body-handles-invalid-json
+ (testing "JSON body middleware returns 400 for invalid JSON"
+ (let [handler (fn [req] {:status 200 :body "ok"})
+ wrapped (mw/wrap-json-body handler)
+ request {:headers {"content-type" "application/json"}
+ :body (ByteArrayInputStream. (.getBytes "not valid json"))}
+ response (wrapped request)]
+ (is (= 400 (:status response))))))
+
+
+(deftest test-wrap-cors-adds-headers
+ (testing "CORS middleware adds headers"
+ (let [handler (fn [_] {:status 200 :headers {} :body "ok"})
+ wrapped (mw/wrap-cors handler)
+ response (wrapped {})]
+ (is (= "*" (get-in response [:headers "Access-Control-Allow-Origin"])))
+ (is (some? (get-in response [:headers "Access-Control-Allow-Methods"])))
+ (is (some? (get-in response [:headers "Access-Control-Allow-Headers"]))))))
+
+
+(deftest test-wrap-exceptions-catches-errors
+ (testing "Exception middleware catches errors"
+ (let [handler (fn [_] (throw (Exception. "Test error")))
+ wrapped (mw/wrap-exceptions handler)
+ response (wrapped {})]
+ (is (= 500 (:status response)))
+ (let [body (parse-json-body response)]
+ (is (contains? body :error))))))
+
+
+;; ============================================================================
+;; Integration tests (through the full app)
+;; ============================================================================
+
+(deftest test-app-datasets-endpoint
+ (testing "Full app handles /api/datasets"
+ (let [response (routes/app {:request-method :get
+ :uri "/api/datasets"})]
+ (is (= 200 (:status response))))))
+
+
+(deftest test-app-root-page
+ (testing "Full app handles root page"
+ (let [response (routes/app {:request-method :get
+ :uri "/"})]
+ ;; Should return 200 for the index page
+ (is (= 200 (:status response))))))
diff --git a/test/org/closyr/core/FindFormulaTest.java b/test/org/closyr/core/FindFormulaTest.java
new file mode 100644
index 00000000..71acee4c
--- /dev/null
+++ b/test/org/closyr/core/FindFormulaTest.java
@@ -0,0 +1,369 @@
+package org.closyr.core;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.matheclipse.core.interfaces.IExpr;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Tests for the FindFormula Java API that calls into Clojure symbolic regression.
+ */
+class FindFormulaTest {
+
+// @BeforeAll
+// static void initClojure() {
+// // Pre-initialize Clojure runtime to avoid timeout in first test
+// FindFormula.initializeClojure();
+// }
+
+ @BeforeEach
+ void setUp() {
+ }
+
+ @AfterEach
+ void tearDown() {
+ }
+
+ @Test
+ void testFindFormulaWithLinearData() {
+ // Simple linear relationship: y = 2x
+ double[] xs = {1.0, 2.0, 3.0, 4.0, 5.0};
+ double[] ys = {2.0, 4.0, 6.0, 8.0, 10.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(10)
+ .populationSize(50);
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+
+ assertNotNull(result);
+ assertNotNull(result.getFormulaString());
+ assertFalse(result.getFormulaString().isEmpty());
+ assertTrue(result.getIterationsDone() > 0);
+ assertNotNull(result.getAllSolutions());
+ assertFalse(result.getAllSolutions().isEmpty());
+
+ System.out.println("Linear data result: " + result);
+ }
+
+ @Test
+ void testFindFormulaWithQuadraticData() {
+ // Quadratic relationship: y = x^2
+ double[] xs = {1.0, 2.0, 3.0, 4.0, 5.0};
+ double[] ys = {1.0, 4.0, 9.0, 16.0, 25.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(15)
+ .populationSize(100);
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+
+ assertNotNull(result);
+ assertNotNull(result.getFormulaString());
+ assertTrue(result.getIterationsDone() > 0);
+
+ System.out.println("Quadratic data result: " + result);
+ }
+
+ @Test
+ void testFindFormulaWithDefaultConfig() {
+ double[] xs = {0.0, 1.0, 2.0, 3.0};
+ double[] ys = {1.0, 2.0, 5.0, 10.0};
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys);
+
+ assertNotNull(result);
+ assertNotNull(result.getFormulaString());
+ assertEquals(20, result.getIterationsDone()); // default iterations
+
+ System.out.println("Default config result: " + result);
+ }
+
+ @Test
+ void testResultContainsSymjaExpr() {
+ double[] xs = {1.0, 2.0, 3.0};
+ double[] ys = {3.0, 6.0, 9.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(5)
+ .populationSize(30);
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+
+ assertNotNull(result);
+ IExpr formulaExpr = result.getFormulaExpr();
+ assertNotNull(formulaExpr, "Formula IExpr should not be null");
+
+ // The IExpr should be usable for symbolic computation
+ String exprString = formulaExpr.toString();
+ assertNotNull(exprString);
+ assertFalse(exprString.isEmpty());
+
+ System.out.println("IExpr formula: " + exprString);
+ }
+
+ @Test
+ void testAllSolutionsSortedByScore() {
+ double[] xs = {1.0, 2.0, 3.0, 4.0};
+ double[] ys = {2.0, 4.0, 8.0, 16.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(5)
+ .populationSize(50);
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+
+ List solutions = result.getAllSolutions();
+ assertNotNull(solutions);
+ assertFalse(solutions.isEmpty());
+
+ // Verify solutions are sorted by score (descending - higher is better)
+ for (int i = 1; i < solutions.size(); i++) {
+ assertTrue(solutions.get(i - 1).getScore() >= solutions.get(i).getScore(),
+ "Solutions should be sorted by score descending");
+ }
+
+ // Best solution should match the result's formula
+ assertEquals(result.getFormulaString(), solutions.get(0).getFormulaString());
+ assertEquals(result.getScore(), solutions.get(0).getScore());
+ }
+
+ @Test
+ void testNullXsThrowsException() {
+ double[] ys = {1.0, 2.0, 3.0};
+
+ IllegalArgumentException exception = assertThrows(
+ IllegalArgumentException.class,
+ () -> FindFormula.findFormula(null, ys)
+ );
+ assertTrue(exception.getMessage().contains("null"));
+ }
+
+ @Test
+ void testNullYsThrowsException() {
+ double[] xs = {1.0, 2.0, 3.0};
+
+ IllegalArgumentException exception = assertThrows(
+ IllegalArgumentException.class,
+ () -> FindFormula.findFormula(xs, null)
+ );
+ assertTrue(exception.getMessage().contains("null"));
+ }
+
+ @Test
+ void testMismatchedArrayLengthsThrowsException() {
+ double[] xs = {1.0, 2.0, 3.0};
+ double[] ys = {1.0, 2.0};
+
+ IllegalArgumentException exception = assertThrows(
+ IllegalArgumentException.class,
+ () -> FindFormula.findFormula(xs, ys)
+ );
+ assertTrue(exception.getMessage().contains("same length"));
+ }
+
+ @Test
+ void testTooFewDataPointsThrowsException() {
+ double[] xs = {1.0};
+ double[] ys = {2.0};
+
+ IllegalArgumentException exception = assertThrows(
+ IllegalArgumentException.class,
+ () -> FindFormula.findFormula(xs, ys)
+ );
+ assertTrue(exception.getMessage().contains("At least 2"));
+ }
+
+ @Test
+ void testConfigBuilder() {
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(50)
+ .populationSize(200)
+ .maxLeafs(30)
+ .randomSeed(12345);
+
+ assertEquals(50, config.getIterations());
+ assertEquals(200, config.getPopulationSize());
+ assertEquals(30, config.getMaxLeafs());
+ assertEquals(12345, config.getRandomSeed());
+ }
+
+ @Test
+ void testConfigBuilderWithEvalCache() {
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(10)
+ .populationSize(50)
+ .useEvalCache(true);
+
+ assertTrue(config.isUseEvalCache());
+
+ // Verify it works with the solver
+ double[] xs = {1.0, 2.0, 3.0};
+ double[] ys = {2.0, 4.0, 6.0};
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+ assertNotNull(result);
+ assertNotNull(result.getFormulaString());
+
+ System.out.println("Result with eval cache: " + result);
+ }
+
+ @Test
+ void testConfigBuilderEvalCacheDefaultsFalse() {
+ FindFormula.Config config = new FindFormula.Config();
+ assertFalse(config.isUseEvalCache());
+ }
+
+ @Test
+ void testConfigBuilderWithScoringMethod() {
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(10)
+ .populationSize(50)
+ .scoringMethod("log-cosh");
+
+ assertEquals("log-cosh", config.getScoringMethod());
+
+ // Verify it works with the solver
+ double[] xs = {1.0, 2.0, 3.0, 4.0, 5.0};
+ double[] ys = {1.0, 4.0, 9.0, 16.0, 25.0};
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+ assertNotNull(result);
+ assertNotNull(result.getFormulaString());
+
+ System.out.println("Result with log-cosh scoring: " + result);
+ }
+
+ @Test
+ void testConfigBuilderScoringMethodDefaultsMaeMax() {
+ FindFormula.Config config = new FindFormula.Config();
+ assertEquals("mae-max", config.getScoringMethod());
+ }
+
+ @Test
+ void testScoringMethodRSquared() {
+ double[] xs = {1.0, 2.0, 3.0, 4.0, 5.0};
+ double[] ys = {2.0, 4.0, 6.0, 8.0, 10.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(5)
+ .populationSize(30)
+ .scoringMethod("r-squared");
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+ assertNotNull(result);
+ assertNotNull(result.getFormulaString());
+ // R-squared scores should be <= 0 (0 is perfect, negative is worse)
+ assertTrue(result.getScore() <= 0.0001, "R-squared score should be <= 0");
+
+ System.out.println("Result with r-squared scoring: " + result);
+ }
+
+ @Test
+ void testRandomSeedProducesDeterministicResults() {
+ double[] xs = {1.0, 2.0, 3.0, 4.0, 5.0};
+ double[] ys = {2.0, 4.0, 6.0, 8.0, 10.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(5)
+ .populationSize(20)
+ .randomSeed(42);
+
+ FindFormula.Result result1 = FindFormula.findFormula(xs, ys, config);
+ FindFormula.Result result2 = FindFormula.findFormula(xs, ys, config);
+
+ assertEquals(result1.getFormulaString(), result2.getFormulaString(),
+ "Same seed should produce identical formulas");
+ assertEquals(result1.getScore(), result2.getScore(),
+ "Same seed should produce identical scores");
+ }
+
+ @Test
+ void testResultToString() {
+ double[] xs = {1.0, 2.0, 3.0};
+ double[] ys = {2.0, 4.0, 6.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(3)
+ .populationSize(20);
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+
+ String str = result.toString();
+ assertNotNull(str);
+ assertTrue(str.contains("Result{"));
+ assertTrue(str.contains("formula="));
+ assertTrue(str.contains("score="));
+ assertTrue(str.contains("iterations="));
+ }
+
+ @Test
+ void testSolutionToString() {
+ double[] xs = {1.0, 2.0, 3.0};
+ double[] ys = {1.0, 4.0, 9.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(3)
+ .populationSize(20);
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+
+ assertFalse(result.getAllSolutions().isEmpty());
+ FindFormula.Solution solution = result.getAllSolutions().get(0);
+
+ String str = solution.toString();
+ assertNotNull(str);
+ assertTrue(str.contains("Solution{"));
+ assertTrue(str.contains("formula="));
+ assertTrue(str.contains("score="));
+ }
+
+ @Test
+ void testWithTrigonometricData() {
+ // Data from y = sin(x)
+ int numPoints = 20;
+ double[] xs = new double[numPoints];
+ double[] ys = new double[numPoints];
+ for (int i = 0; i < numPoints; i++) {
+ xs[i] = i * Math.PI / 10.0;
+ ys[i] = Math.sin(xs[i]);
+ }
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(15)
+ .populationSize(100);
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+
+ assertNotNull(result);
+ assertNotNull(result.getFormulaString());
+ // Trigonometric functions are complex, just verify we get a result
+ assertTrue(result.getAllSolutions().size() > 0);
+
+ System.out.println("Trig data result: " + result);
+ }
+
+ @Test
+ void testInitializeClojureIdempotent() {
+// // Should be safe to call multiple times
+// FindFormula.initializeClojure();
+// FindFormula.initializeClojure();
+// FindFormula.initializeClojure();
+
+ // Verify the API still works
+ double[] xs = {1.0, 2.0};
+ double[] ys = {1.0, 2.0};
+
+ FindFormula.Config config = new FindFormula.Config()
+ .iterations(2)
+ .populationSize(10);
+
+ FindFormula.Result result = FindFormula.findFormula(xs, ys, config);
+ assertNotNull(result);
+ }
+}