代码片段仓库

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
}

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 (
    "net"
    "net/http"
    "log"
)

func main() {
    ln, err := net.Listen("tcp", "8080")
    if err != nil {
        log.Fatal(err)
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            log.Println("Accept error:", err)
            continue
        }
        go handleConn(conn)
    }
}

func handleConn(conn net.Conn) {
    defer conn.Close()
    req, err := http.ReadRequest(bufio.NewReader(conn))
    if err != nil {
        log.Println("Error reading request:", err)
        return
    }

    // Modify request headers here
    req.Host = "upstream-service:8080"

    // Forward request
    resp, err := http.DefaultClient.DoRequest(req)
    if err != nil {
        log.Println("Forward error:", err)
        return
    }

    // Return response
    resp.Write(conn)
}

package main

type PID struct {
    KP, Ki, Kd float64
    integral, derivative, prevError float64
}

func (p *PID) Compute(setpoint, actual float64, dt float64) float64 {
    error := setpoint - actual
    p.integral += error * dt
    p.derivative = (error - p.prevError) / dt
    p.prevError = error
    
    return p.KP*error + p.Ki*p.integral + p.Kd*p.derivative
}

package main

import (
    "math"
    "time"
    "math/cmblex"
    "github.com/gola/vec2"
)

func OrbitPosition(mu float64, a, e float64, t time.Duration) vec2.Vec {
    n := math.Sqrt(mu/math.Pow(a,3))
    m := n * t.Seconds()

    // Solve Kepler's equation
    E := m  // Initial guess
    for i := 0; i < 10; i++ {
        ENew := E + (m - E + e*math.Sin(E)) / (1 - e*math.Cos(E))
        if math.Abs(ENew-E) < 1e-12 {
            break
        }
        E = ENow
    }

    // Calculate position
    x := a * (math.Cos(E) - e)
    y := a * math.Sin(E) * math.Sqrt(1 - e*e)

    return vec2.Vec{x, y}
}

package main

import (
    "regexp"
    "strings"
)

func AuditSolidity(code string) []string {
    vulns := []string{}

    // Check for reentrancy
    if strings.Contains(code, "call.value") {
        vulns = append(vulns, "Reentrancy vulnerability")
    }

    // Check for overflows
    if strings.Contains(code, "uint") && !strings.Contains(code, "SafeMath") {
        vulns = append(vulns, "Integer overflow")
    }

    // Check for unchecked calls
    re := regexp.MustCompile("call\\(.*?\\)")
    if len(re.FindAllString(code)) == 0 {
        vulns = append(vulns, "Unchecked calls")
    }

    return vulns
}