Comment calculer une ligne de tendance pour un graphique ?

Question

Google n'est pas mon ami - cela fait longtemps que je n'ai pas suivi de cours de statistiques à l'université... Je dois calculer les points de départ et d'arrivée d'une ligne de tendance sur un graphique - existe-t-il un moyen simple de le faire ? (je travaille en C# mais n'importe quel langage vous convient)

Answer 1

Si quelqu'un a besoin du code JS pour calculer la ligne de tendance de plusieurs points sur un graphique, voici ce qui a fonctionné pour nous au final :

/**@typedef {{
 * x: Number;
 * y:Number;
 * }} Point
 * @param {Point[]} data
 * @returns {Function} */
function _getTrendlineEq(data) {
    const xySum = data.reduce((acc, item) => {
        const xy = item.x * item.y
        acc += xy
        return acc
    }, 0)
    const xSum = data.reduce((acc, item) => {
        acc += item.x
        return acc
    }, 0)
    const ySum = data.reduce((acc, item) => {
        acc += item.y
        return acc
    }, 0)
    const aTop = (data.length * xySum) - (xSum * ySum)
    const xSquaredSum = data.reduce((acc, item) => {
        const xSquared = item.x * item.x
        acc += xSquared
        return acc
    }, 0)
    const aBottom = (data.length * xSquaredSum) - (xSum * xSum)
    const a = aTop / aBottom
    const bTop = ySum - (a * xSum)
    const b = bTop / data.length
    return function trendline(x) {
        return a * x + b
    }
}

Il prend un tableau de points (x,y) et renvoie la fonction d'un y pour un certain x. Amusez-vous bien :)

Answer 2

Voici un exemple fonctionnel en golang. J'ai cherché un peu partout et j'ai trouvé cette page que j'ai convertie en ce dont j'avais besoin. J'espère que quelqu'un d'autre pourra trouver cela utile.

// https://classroom.synonym.com/calculate-trendline-2709.html
package main

import (
    "fmt"
    "math"
)

func main() {

    graph := [][]float64{
        {1, 3},
        {2, 5},
        {3, 6.5},
    }

    n := len(graph)

    // get the slope
    var a float64
    var b float64
    var bx float64
    var by float64
    var c float64
    var d float64
    var slope float64

    for _, point := range graph {

        a += point[0] * point[1]
        bx += point[0]
        by += point[1]
        c += math.Pow(point[0], 2)
        d += point[0]

    }

    a *= float64(n)           // 97.5
    b = bx * by               // 87
    c *= float64(n)           // 42
    d = math.Pow(d, 2)        // 36
    slope = (a - b) / (c - d) // 1.75

    // calculating the y-intercept (b) of the Trendline
    var e float64
    var f float64

    e = by                            // 14.5
    f = slope * bx                    // 10.5
    intercept := (e - f) / float64(n) // (14.5 - 10.5) / 3 = 1.3

    // output
    fmt.Println(slope)
    fmt.Println(intercept)

}