Use our tool to project voting results in contested Jackson elections

tables.forEach((table, tableIndex) => { // Check if table contains {{variables}} const hasVariables = table.innerHTML.includes('{{'); if (!hasVariables) return;

// Create calculator instance for this table const calculator = new TableCalculator(table, tableIndex); calculator.initialize(); }); }

class TableCalculator { constructor(table, tableIndex) { this.table = table; this.tableIndex = tableIndex; this.variables = {}; this.validations = {}; this.formulas = {}; this.cells = new Map(); }

initialize() { this.parseTable(); this.createInputs(); this.setDefaultValues(); this.calculate(); }

parseTable() { const cells = this.table.querySelectorAll('td, th');

cells.forEach(cell => { const content = cell.textContent.trim(); const match = content.match(/\{\{(.+?)\}\}/);

if (match) { const expression = match[1].trim(); const cellId = `table${this.tableIndex}_${Array.from(cells).indexOf(cell)}`;

// Check if it's a validation (contains ==) if (expression.includes('==')) { const [left, right] = expression.split('==').map(s => s.trim()); this.validations[cellId] = { cell: cell, left: left, right: right, expression: expression }; } // Check if it's a default value (single =) else if (expression.includes('=') && !expression.includes('*') && !expression.includes('+') && !expression.includes('-') && !expression.includes('/')) { const [varName, defaultValue] = expression.split('=').map(s => s.trim()); this.variables[varName] = { cell: cell, defaultValue: parseFloat(defaultValue), cellId: cellId }; } // Otherwise it's a formula else { this.formulas[cellId] = { cell: cell, expression: expression }; }

this.cells.set(cellId, cell); } }); }

createInputs() { // Create inputs for variables Object.entries(this.variables).forEach(([varName, varData]) => { const input = document.createElement('input'); input.type = 'number'; input.min = '0'; input.step = '1'; input.value = varData.defaultValue; input.style.cssText = ` width: 60px; text-align: center; border: 1px solid #007cba; border-radius: 4px; padding: 0; font-weight: bold; background-color: #f0f8ff; `;

input.addEventListener('input', () => { this.handleBalancedInputs(varName, input); this.calculate(); });

// Replace cell content with input + % sign const container = document.createElement('div'); container.style.cssText = 'display: flex; align-items: center; justify-content: center; gap: 2px;'; container.appendChild(input); container.appendChild(document.createTextNode('%'));

varData.cell.innerHTML = ''; varData.cell.appendChild(container); varData.input = input; });

// Prepare validation cells Object.values(this.validations).forEach(validation => { validation.cell.innerHTML = ''; validation.cell.style.padding = '8px'; });

// Prepare formula cells Object.values(this.formulas).forEach(formula => { formula.cell.style.cssText += 'font-weight: bold; background-color: #f9f9f9;'; }); }

handleBalancedInputs(changedVarName, changedInput) { // Define balanced pairs - add more pairs as needed const balancedPairs = [ ['sb', 'sw'], ['sw', 'sb'] ];

// Find if this variable is part of a balanced pair const pair = balancedPairs.find(p => p[0] === changedVarName); if (!pair) return;

const partnerVarName = pair[1]; const partnerVar = this.variables[partnerVarName];

if (partnerVar && partnerVar.input) { const changedValue = parseFloat(changedInput.value) || 0; const newPartnerValue = 100 - changedValue;

// Ensure the partner value stays within bounds if (newPartnerValue >= 0 && newPartnerValue <= 100) { partnerVar.input.value = newPartnerValue; } else { // If partner would go out of bounds, adjust the changed value instead const maxChangedValue = changedValue > 100 ? 100 : (changedValue < 0 ? 0 : changedValue); changedInput.value = maxChangedValue; partnerVar.input.value = 100 - maxChangedValue; } } } setDefaultValues() { Object.entries(this.variables).forEach(([varName, varData]) => { if (varData.input) { varData.input.value = varData.defaultValue; } }); }

getVariableValue(varName) { const varData = this.variables[varName]; if (!varData || !varData.input) return 0;

const value = parseFloat(varData.input.value) || 0; return value / 100; // Convert percentage to decimal for calculations }

evaluateExpression(expression) { try { // Replace variable names with their values let evalExpression = expression; Object.keys(this.variables).forEach(varName => { const value = this.getVariableValue(varName); evalExpression = evalExpression.replace(new RegExp(`\\b${varName}\\b`, 'g'), value.toString()); });

// Safely evaluate the expression const result = Function(`"use strict"; return (${evalExpression})`)(); return result; } catch (error) { console.error('Error evaluating expression:', expression, error); return 0; } }

calculate() { let hasValidationErrors = false;

// Clear previous error highlighting this.table.querySelectorAll('.validation-error').forEach(cell => { cell.classList.remove('validation-error'); cell.style.backgroundColor = ''; });

// Check validations first Object.values(this.validations).forEach(validation => { const leftValue = this.evaluateExpression(validation.left); const rightValue = this.evaluateExpression(validation.right);

const isValid = Math.abs(leftValue - rightValue) < 0.001; // Allow small floating point differences if (!isValid) { hasValidationErrors = true; validation.cell.innerHTML = `Must add up to 100%.`;

// Highlight all variables involved in this validation const allVars = [...validation.left.matchAll(/\b[a-zA-Z_][a-zA-Z0-9_]*\b/g), ...validation.right.matchAll(/\b[a-zA-Z_][a-zA-Z0-9_]*\b/g)];

allVars.forEach(match => { const varName = match[0]; if (this.variables[varName]) { this.variables[varName].cell.style.backgroundColor = 'rgba(255, 0, 0, 0.2)'; this.variables[varName].cell.classList.add('validation-error'); } }); } else { validation.cell.innerHTML = ''; } });

// Calculate formulas only if no validation errors if (!hasValidationErrors) { Object.values(this.formulas).forEach(formula => { const result = this.evaluateExpression(formula.expression); const percentage = Math.round(result * 100); // Convert back to percentage and round formula.cell.innerHTML = `${percentage}%`; }); } else { // Clear formula cells if validation fails Object.values(this.formulas).forEach(formula => { formula.cell.innerHTML = ''; }); } } }

// Initialize when DOM is ready if (document.readyState === 'loading') { document.addEventListener('DOMContentLoaded', initializeTableCalculators); } else { initializeTableCalculators(); }