使用 Groovy、Apache Commons Math、ojAlgo、Nd4j 和 EJML 进行矩阵计算

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233

double[] init = [400,   // 0..<3
                 400,   // 3..<6
                 400]   // 6..9
def p0 = MatrixUtils.createRealVector(init)
println "Initial populations: $p0"

double[][] data = [
        [0  , 2.3, 0.4],   // B1 B2 B3
        [0.6,   0, 0  ],   // S1  0  0
        [0  , 0.3, 0  ]    //  0 S2  0
]
def L = MatrixUtils.createRealMatrix(data)
def p1 = L.operate(p0)
println "Population after 1 round: $p1"

def p2 = L.operate(p1)
println "Population after 2 rounds: $p2"

def L10 = L ** 10
println "Population after 10 rounds: ${L10.operate(p0).toArray()*.round()}"

Initial populations: {400; 400; 400}
Population after 1 round: {1,080; 240; 120}
Population after 2 rounds: {600; 648; 72}
Population after 10 rounds: [3019, 2558, 365]

double[][] encode(String s) { s.bytes*.intValue().collate(3) as double[][] }
String decode(double[] data) { data*.round() as char[] }

def message = 'GROOVY'
def m = new SimpleMatrix(encode(message))
println "Original: $message"

def enKey = new SimpleMatrix([[1, 3], [-1, 2]] as double[][])
def encrypted = enKey.mult(m)
println "Encrypted: ${decode(encrypted.matrix.data)}"

def deKey = enKey.invert()
def decrypted = deKey.mult(encrypted)
println "Decrypted: ${decode(decrypted.matrix.data)}"

Original: GROOVY
Encrypted: ĴŔŚWZc
Decrypted: GROOVY

new SwingBuilder().edt {
    def frame = frame(title: 'Shapes', size: [420, 440], show: true, defaultCloseOperation: DISPOSE_ON_CLOSE) {
        //contentPane.background = Color.WHITE
        widget(new CustomPaintComponent())
    }
    frame.contentPane.background = Color.WHITE
}

class CustomPaintComponent extends Component {
    static final Color violet = new Color(0x67, 0x27, 0x7A, 127)
    static final Color seaGreen = new Color(0x69, 0xCC, 0x67, 127)
    static final Color crystalBlue = new Color(0x06, 0x4B, 0x93, 127)
    static drawPolygon(Graphics g, List pts, boolean fill) {
        def poly = new Polygon().tap {
            pts.each {
                addPoint(*it.toRawCopy1D()*.round()*.intValue().collect { it + 200 })
            }
        }
        fill ? g.fillPolygon(poly) : g.drawPolygon(poly)
    }

    static List<Primitive64Matrix> vectors(List<Integer>... pts) {
        pts.collect{ factory.column(*it) }
    }

    static transform(List<Number>... lists) {
        factory.rows(lists as double[][])
    }

    void paint(Graphics g) {
        g.drawLine(0, 200, 400, 200)
        g.drawLine(200, 0, 200, 400)
        g.stroke = new BasicStroke(2)

        def triangle = vectors([-85, -150], [-145, -30], [-25, -30])
        g.color = seaGreen
        drawPolygon(g, triangle, true)
        // transform triangle
        ...

        def rectangle = vectors([0, -110], [0, -45], [95, -45], [95, -110])
        g.color = crystalBlue
        drawPolygon(g, rectangle, true)
        // transform rectangle
        ...

        def trapezoid = vectors([50, 50], [70, 100], [100, 100], [120, 50])
        g.color = violet
        drawPolygon(g, trapezoid, true)
        // transform trapezoid
        ...
    }
}

def rot90 = transform([0, 1], [-1, 0])
def bigger = transform([1.25, 0], [0, 1.25])
def smaller = transform([0.75, 0], [0, 0.75])
def triangle_ = triangle.collect{ rot90 * bigger * it }
drawPolygon(g, triangle_, false)
triangle_ = triangle.collect{ rot90 * smaller * it }
drawPolygon(g, triangle_, false)

def flipV = transform([1, 0], [0, -1])
def rectangle_ = rectangle.collect{ flipV * it }
drawPolygon(g, rectangle_, false)
def flipH_shear = transform([-1, 0.5], [0, 1])
rectangle_ = rectangle.collect{ flipH_shear * it }
drawPolygon(g, rectangle_, false)

def rot45 = transform([0.707, 0.707], [-0.707, 0.707])
def trapezoid_
(1..6).each { z ->
    trapezoid_ = trapezoid.collect{ rot45 ** z * it }
    drawPolygon(g, trapezoid_, false)
}

RealMatrix.metaClass {
  plus << { RealMatrix ma -> delegate.add(ma) }
  plus << { double d -> delegate.scalarAdd(d) }
  multiply { double d -> delegate.scalarMultiply(d) }
  bitwiseNegate { -> new LUDecomposition(delegate).solver.inverse }
  constructor = { List l -> MatrixUtils.createRealMatrix(l as double[][]) }
}

var m = [[1, 1], [1, 0]] as Matrix
m**6