Min Max Regression Calculation

2025-03-06 12:35 UTC gpt-4-5 Open in ChatGPT ↗

Yes, you can extract the minimum and maximum values from a regression line computed by Observable Plot by manually calculating them from the regression output.

Observable Plot’s linearRegressionY transform doesn’t directly provide min and max values in its output, but you can easily determine these by:

Approach:

Fit the linear regression:
Compute the slope and intercept using Plot’s internal method or via JavaScript directly.
Compute min and max:
Evaluate the regression line at the minimum and maximum x-values of your data to get the corresponding y-values.

Here’s an explicit example:

Example in JavaScript:

Assuming you have data like this:

const data = [
  {x: 1, y: 2},
  {x: 2, y: 3},
  {x: 3, y: 5},
  {x: 4, y: 4},
  {x: 5, y: 6}
];

// Compute linear regression parameters manually (using simple formulas)
function linearRegression(data) {
  const n = data.length;
  const sumX = data.reduce((acc, d) => acc + d.x, 0);
  const sumY = data.reduce((acc, d) => acc + d.y, 0);
  const sumXY = data.reduce((acc, d) => acc + d.x * d.y, 0);
  const sumXX = data.reduce((acc, d) => acc + d.x * d.x, 0);

  const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
  const intercept = (sumY - slope * sumX) / n;

  return { slope, intercept };
}

const { slope, intercept } = linearRegression(data);

// Get min and max x values from your data
const xMin = Math.min(...data.map(d => d.x));
const xMax = Math.max(...data.map(d => d.x));

// Evaluate regression at min and max x
const yMin = slope * xMin + intercept;
const yMax = slope * xMax + intercept;

console.log("Min regression point:", { x: xMin, y: yMin });
console.log("Max regression point:", { x: xMax, y: yMax });

Using Observable Plot’s built-in regression line:

If you’re already using Observable Plot and just want to get the computed regression min/max visually:

Plot.plot({
  marks: [
    Plot.dot(data, { x: "x", y: "y" }),
    Plot.linearRegressionY(data, { x: "x", y: "y", stroke: "blue" }),
    Plot.text(
      [
        { x: xMin, y: yMin, label: `Min: (${xMin.toFixed(2)}, ${yMin.toFixed(2)})` },
        { x: xMax, y: yMax, label: `Max: (${xMax.toFixed(2)}, ${yMax.toFixed(2)})` }
      ],
      { x: "x", y: "y", text: "label", dy: -10 }
    )
  ]
});

This approach explicitly computes and highlights the min and max regression values directly.

in my data there is a “time” column, and then my variable.

const transformedData = data.map(d => ({
    ...d,
    [column]: column.toLowerCase().includes("temperature") && d[column] > 100 ? d[column] - 273.15 : d[column]
}));

perform linear regression on this, and then find min and max of the regreession

Here’s how you can perform linear regression on your data (assuming your data has a time column and another numeric column) and calculate the min/max points of the regression line explicitly:

Step-by-step implementation:

Assuming your transformed data looks like this:

const transformedData = data.map(d => ({
  ...d,
  [column]: column.toLowerCase().includes("temperature") && d[column] > 100
    ? d[column] - 273.15
    : d[column]
}));

You can compute linear regression and find min/max points like this:

Full Example:

// Utility function to perform linear regression:
function linearRegression(data, xAccessor, yAccessor) {
  const n = data.length;
  const sumX = data.reduce((acc, d) => acc + xAccessor(d), 0);
  const sumY = data.reduce((acc, d) => acc + yAccessor(d), 0);
  const sumXY = data.reduce((acc, d) => acc + xAccessor(d) * yAccessor(d), 0);
  const sumXX = data.reduce((acc, d) => acc + xAccessor(d) ** 2, 0);

  const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX ** 2);
  const intercept = (sumY - slope * sumX) / n;

  return { slope, intercept };
}

// Perform regression (assuming your time variable is numeric or convertible):
const { slope, intercept } = linearRegression(
  transformedData,
  d => +new Date(d.time),    // x-axis (time converted to numeric)
  d => d[column]             // y-axis
);

// Compute min/max regression points:
const timesNumeric = transformedData.map(d => +new Date(d.time));
const xMin = Math.min(...timesNumeric);
const xMax = Math.max(...timesNumeric);

const yMin = slope * xMin + intercept;
const yMax = slope * xMax + intercept;

// Convert timestamps back to dates if necessary:
const minPoint = { time: new Date(xMin), value: yMin };
const maxPoint = { time: new Date(xMax), value: yMax };

console.log("Regression min point:", minPoint);
console.log("Regression max point:", maxPoint);

Visualization with Observable Plot:

Here’s how you can visualize it nicely:

Plot.plot({
  x: { type: "utc" },
  marks: [
    Plot.dot(transformedData, { x: d => new Date(d.time), y: d => d[column], fill: "gray" }),
    Plot.linearRegressionY(transformedData, { x: d => new Date(d.time), y: d => d[column], stroke: "blue" }),
    Plot.text(
      [minPoint, maxPoint],
      {
        x: d => d.time,
        y: d => d.value,
        text: d => `(${d.value.toFixed(2)})`,
        dy: -10,
        fill: "red"
      }
    )
  ]
});

Summary:

Perform the regression manually to obtain slope/intercept.
Evaluate the regression at min/max time values to get min/max points.
Visualize clearly indicating min and max regression points on the Observable Plot.

The error:

Maximum call stack size exceeded

usually occurs if your array (timesNumeric) is extremely large. Spreading a very large array (...timesNumeric) directly into functions like Math.min or Math.max exceeds JavaScript’s stack limit.

✅ Solution: Use `reduce()` or a simpler approach to find min/max without spread (`...`)

Replace your lines with the following:

const xMin = timesNumeric.reduce((a, b) => Math.min(a, b), Infinity);
const xMax = timesNumeric.reduce((a, b) => Math.max(a, b), -Infinity);

This approach is memory-efficient and won’t hit the call stack limit.

✅ Full corrected snippet:

// Convert your times to numeric first
const timesNumeric = transformedData.map(d => +new Date(d.time));

// Efficient min/max calculation
const xMin = timesNumeric.reduce((a, b) => Math.min(a, b), Infinity);
const xMax = timesNumeric.reduce((a, b) => Math.max(a, b), -Infinity);

// Compute corresponding y values from regression
const yMin = slope * xMin + intercept;
const yMax = slope * xMax + intercept;

const minPoint = { time: new Date(xMin), value: yMin };
const maxPoint = { time: new Date(xMax), value: yMax };

console.log("Regression min point:", minPoint);
console.log("Regression max point:", maxPoint);

🚩 Explanation:

Using reduce is O(n) and won’t cause call-stack errors.
Using the spread operator (...) for very large arrays is not recommended due to the internal implementation’s stack limitations.

Replace your existing code with the snippet above, and your issue should be resolved.

To calculate snow depth from Snow Water Equivalent (SWE) and snow density, you can use the following formula:

$ \text{Snow Depth} = \frac{\text{SWE}}{\text{Snow Density}} $

Where:

Snow Depth is the height of the snowpack (in meters).
SWE is the Snow Water Equivalent, representing the depth of water that would result if the snowpack melted entirely (in meters).
Snow Density is the mass of snow per unit volume, typically expressed as a fraction or percentage of water density. citeturn0search6

Example Calculation:

If the SWE is 0.2 meters and the snow density is 400 kg/m³:

$ \text{Snow Depth} = \frac{0.2, \text{m}}{400, \text{kg/m}^3} = 0.0005, \text{m} = 0.5, \text{cm} $

*Note: Ensure that units are consistent when performing the calculation.*

Typical Snow Density in the Beskydy Region, Czech Republic:

Snow density varies based on factors like temperature, moisture content, and compaction over time. Specific data for the Beskydy region is limited; however, general observations indicate that:

Freshly fallen snow typically has a density ranging from 100 to 200 kg/m³.
Compacted or older snow can have densities between 200 and 400 kg/m³.

Given the climate of the Czech Republic, with cold winters and frequent snowfall, it’s reasonable to estimate that snow densities in the Beskydy region fall within these ranges. citeturn0search1

For precise measurements, local meteorological data or field measurements would provide more accurate snow density values specific to the Beskydy area.