A Swift library for graph visualization and efficient force simulation.
\n \n\n \n \n \n\n\n \n \n\n## Examples\n\n### Force Directed Graph\nThis is a force directed graph visualizing [the network of character co-occurence in _Les Misérables_](https://observablehq.com/@d3/force-directed-graph-component). Take a closer look at the animation:\n\n\n\nhttps://github.com/swiftgraphs/Grape/assets/45376537/d80dc797-1980-4755-85b9-18ee26e2a7ff\n\n\n\nSource code: [Miserables.swift](https://github.com/swiftgraphs/Grape/blob/main/Examples/ForceDirectedGraphExample/ForceDirectedGraphExample/Miserables.swift). \n\n\n\n \n\n### Force Directed Graph in visionOS\n\nThis is the same graph as the first example, rendered in `RealityView`:\n\n\n\nhttps://github.com/swiftgraphs/Grape/assets/45376537/4585471e-2339-4aee-8f39-0c11fdfb6901\n\n\n\nSource code: [ForceDirectedGraph3D/ContentView.swift](https://github.com/swiftgraphs/Grape/blob/main/Examples/ForceDirectedGraph3D/ForceDirectedGraph3D/ContentView.swift).\n\n\n \n\n\n### Mermaid Visualization\n\nDynamical graph structure based on your input, with tap and drag gesture supports, all within 100 lines of view body.\n\nhttps://github.com/swiftgraphs/Grape/assets/45376537/7c75d367-d5a8-4316-813b-288b375f513b\n\n\n\nSource code: [MermaidVisualization.swift](https://github.com/swiftgraphs/Grape/blob/main/Examples/ForceDirectedGraphExample/ForceDirectedGraphExample/MermaidVisualization.swift)\n\n \n\n\n \n \n### Lattice Simulation\n\nA 36x36 force directed lattice.\n\n\n\nhttps://github.com/swiftgraphs/Grape/assets/45376537/5b76fddc-dd5c-4d35-bced-29c01269dd2b\n\nSource code: [Lattice.swift](https://github.com/swiftgraphs/Grape/blob/main/Examples/ForceDirectedGraphExample/ForceDirectedGraphExample/Lattice.swift)\n\n\n\n\n \n\n### Dragging Gesture\n\nAn example rendering a ring with 60 vertices, with dragging gesture enabled.\n\n\n\nhttps://github.com/swiftgraphs/Grape/assets/45376537/73213e7f-73ee-44f3-9b3e-7e58355045d2\n\nSource code: [MyRing.swift](https://github.com/swiftgraphs/Grape/blob/main/Examples/ForceDirectedGraphExample/ForceDirectedGraphExample/MyRing.swift)\n\n\n \n\n \n\n\n## Installation\n\nTo use Grape in an Xcode project by adding it to your project as a package:\n\n```\nhttps://github.com/swiftgraphs/Grape\n```\n\nTo use Grape in a [SwiftPM](https://swift.org/package-manager/) project, add this to your `Package.swift`:\n\n``` swift\ndependencies: [\n .package(url: \"https://github.com/swiftgraphs/Grape\", from: \"1.1.0\")\n]\n```\n\n```swift\n.product(name: \"Grape\", package: \"Grape\"),\n```\n\n> [!NOTE]\n> The `Grape` module relies on the [`Observation` framework](https://developer.apple.com/documentation/observation). It’s possible to backdeploy with community shims like [`swift-perception`](https://github.com/pointfreeco/swift-perception).\n> \n> The `Grape` module may introduce breaking API changes in minor version changes before 1.0 release.\n>\n> The `ForceSimulation` module is stable in terms of public API now.\n\n \n\n \n\n## Get started\n\nGrape ships 2 modules:\n\n- The `Grape` module allows you to create force-directed graphs in SwiftUI Views.\n- The `ForceSimulation` module is the underlying mechanism of `Grape`, and it helps you to create more complicated or customized force simulations. It also contains a `KDTree` data structure built with performance in mind, which can be useful for spatial partitioning tasks.\n\n\n \n\n### The `Grape` module\n\n\nFor detailed usage, please refer to [documentation](https://swiftgraphs.github.io/Grape/Grape/documentation/grape). A quick example here:\n\n```swift\nimport Grape\n\nstruct MyGraph: View {\n\n // States including running status, transformation, etc.\n // Gives you a handle to control the states.\n @State var graphStates = ForceDirectedGraphState() \n \n var body: some View {\n ForceDirectedGraph(states: graphStates) {\n \n // Declare nodes and links like you would do in Swift Charts.\n NodeMark(id: 0).foregroundStyle(.green)\n NodeMark(id: 1).foregroundStyle(.blue)\n NodeMark(id: 2).foregroundStyle(.yellow)\n\n Series(0..<2) { i in\n LinkMark(from: i, to: i+1)\n }\n \n } force: {\n .link()\n .center()\n .manyBody()\n }\n }\n}\n```\n\n\n\n \n\n\n### The `ForceSimulation` module\n\n Refer to the documentation or expand this section to find more about this module.\n \n\n`ForceSimulation` module mainly contains 3 concepts, `Kinetics`, `ForceProtocol` and `Simulation`.\n\n
\n \n
\n\n \n- `Kinetics` describes all kinetic states of your system, i.e. position, velocity, link connections, and the variable `alpha` that describes how \"active\" your system is.\n- Forces are any types that conforms to `ForceProtocol`. This module provides most of the forces you will use in force directed graphs. And you can also create your own forces. They should be responsible for 2 tasks:\n - `bindKinetics(_ kinetics: Kinetics)`: binding to a `Kinetics`. In most cases the force should keep a reference of the `Kinetics` so they know what to mutate when `apply` is called.\n - `apply()`: Mutating the states of `Kinetics`. For example, a gravity force should add velocities on each node in this function.\n- `Simulation` is a shell class you interact with, which enables you to create any dimensional simulation with velocity Verlet integration. It manages a `Kinetics` and a force conforming to `ForceProtocol`. Since `Simulation` only stores one force, you are responsible for compositing multiple forces into one.\n- Another data structure `KDTree` is used to accelerate the force simulation with [Barnes-Hut Approximation](https://jheer.github.io/barnes-hut/).\n\n \n\nThe basic concepts of simulations and forces can be found here: [Force simulations - D3](https://d3js.org/d3-force/simulation). You can simply create simulations by using `Simulation` like this:\n\n```swift\nimport simd\nimport ForceSimulation\n\n// assuming you’re simulating 4 nodes\nlet nodeCount = 4\n\n\n// Connect them\nlet links = [(0, 1), (1, 2), (2, 3), (3, 0)] \n\n/// Create a 2D force composited with 4 primitive forces.\nlet myForce = SealedForce2D {\n // Forces are namespaced under `Kinetics`\n // here we only use `Kinetics>`, i.e. `Kinetics2D`\n Kinetics2D.ManyBodyForce(strength: -30)\n Kinetics2D.LinkForce(\n stiffness: .weightedByDegree(k: { _, _ in 1.0 }),\n originalLength: .constant(35)\n )\n Kinetics2D.CenterForce(center: .zero, strength: 1)\n Kinetics2D.CollideForce(radius: .constant(3))\n}\n\n/// Create a simulation, the dimension is inferred from the force.\nlet mySimulation = Simulation(\n nodeCount: nodeCount,\n links: links.map { EdgeID(source: $0.0, target: $0.1) },\n forceField: myForce\n) \n\n/// Force is ready to start! run `tick` to iterate the simulation.\n\nfor mySimulation in 0..<120 {\n mySimulation.tick()\n let positions = mySimulation.kinetics.position.asArray()\n /// Do something with the positions.\n}\n\n```\n\nSee [Example](https://github.com/swiftgraphs/Grape/tree/main/Examples/ForceDirectedGraphExample) for more details. \n\n\n\n\n\n \n\n \n\n\n## Roadmap\n\n| | 2D simd | ND simd | Metal |\n| --- | --- | --- | --- |\n| **NdTree** | ✅ | ✅ | |\n| **Simulation** | ✅ | ✅ | |\n| LinkForce | ✅ | ✅ | |\n| ManyBodyForce | ✅ | ✅ | |\n| CenterForce | ✅ | ✅ | |\n| CollideForce | ✅ | ✅ | |\n| PositionForce | ✅ | ✅ | |\n| RadialForce | ✅ | ✅ | |\n| **SwiftUI View** | ✅ | | |\n| Basic Visualization | ✅ | | |\n| Gestures | ✅ | | |\n| Node Styling | ✅ | | |\n| Link Styling | 🚧 | | |\n| Animatable Transition | 🚧 | | |\n\n \n\n \n\n## Performance\n\n \n\n#### Simulation\n\nGrape uses simd to calculate position and velocity. Currently it takes **~0.005** seconds to iterate 120 times over the example graph(2D). (77 vertices, 254 edges, with manybody, center, collide and link forces. Release build on a M1 Max, [tested](https://github.com/swiftgraphs/Grape/blob/main/Tests/ForceSimulationTests/MiserableGraphTest.swift) with command `swift test -c release`)\n\nFor 3D simulation, it takes **~0.008** seconds for the same graph and same configs.\n\n> [!IMPORTANT]\n> Due to heavy use of generics (some are not specialized in Debug mode), the performance in Debug build is ~100x slower than Release build. \n\n \n\n#### KDTree\nThe `BufferedKDTree` from this package is **~22x** faster than `GKQuadtree` from Apple’s GameKit, according to this [test case](https://github.com/swiftgraphs/Grape/blob/main/Tests/ForceSimulationTests/GKTreeCompareTest.swift). However, please note that comparing Swift structs with NSObjects is unfair, and their behaviors are different.\n\n\n \n\n## Credits\n\nThis library has been greatly influenced by the outstanding work done by [D3.js (Data-Driven Documents)](https://d3js.org).\n"
},
{
"path": "Sources/ForceSimulation/ForceProtocol.swift",
"content": "/// A protocol that represents a force.\n///\n/// A force takes a simulation state and modifies its node positions and velocities.\npublic protocol ForceProtocol {\n associatedtype Vector where Vector: SimulatableVector & L2NormCalculatable\n\n /// Takes a simulation state and modifies its node positions and velocities.\n /// This is executed in each tick of the simulation.\n @inlinable func apply(to kinetics: inout Kinetics)\n\n /// Bind to a kinetic system that describes the state of all nodes in your simulation.\n /// This has to be called before `apply` is called.\n @inlinable mutating func bindKinetics(_ kinetics: Kinetics)\n \n /// Deinitialize the tree and deallocate the memory.\n /// Called when `Simulation` is deinitialized.\n @inlinable func dispose()\n}\n\n\npublic protocol Force2D: ForceProtocol where Vector == SIMD2 {}\npublic protocol Force3D: ForceProtocol where Vector == SIMD3 {}\n\nextension Kinetics2D.LinkForce: Force2D {}\nextension Kinetics2D.ManyBodyForce: Force2D {}\nextension Kinetics2D.CenterForce: Force2D {}\nextension Kinetics2D.CollideForce: Force2D {}\nextension Kinetics2D.PositionForce: Force2D {}\nextension Kinetics2D.RadialForce: Force2D {}\nextension Kinetics2D.EmptyForce: Force2D {}\nextension CompositedForce: Force2D where Vector == SIMD2 {}\n\nextension Kinetics3D.LinkForce: Force3D {}\nextension Kinetics3D.ManyBodyForce: Force3D {}\nextension Kinetics3D.CenterForce: Force3D {}\nextension Kinetics3D.CollideForce: Force3D {}\nextension Kinetics3D.PositionForce: Force3D {}\nextension Kinetics3D.RadialForce: Force3D {}\nextension Kinetics3D.EmptyForce: Force3D {}\nextension CompositedForce: Force3D where Vector == SIMD3 {}\n\npublic protocol ForceDescriptor: Equatable {\n associatedtype ConcreteForce: ForceProtocol\n func createForce() -> ConcreteForce\n}\n\n/// A helper force for hiding long type signatures you composed with `CompositedForce`.\n/// You can easily build a force with a result builder.\npublic protocol ForceField: ForceProtocol\nwhere Vector: SimulatableVector & L2NormCalculatable {\n associatedtype F: ForceProtocol where F.Vector == Vector\n\n @inlinable\n @ForceBuilder\n var force: F { get set }\n}\n\nextension ForceField {\n // @inlinable\n // public func apply() {\n // self.force.apply()\n // }\n\n @inlinable\n public func apply(to kinetics: inout Kinetics) {\n self.force.apply(to: &kinetics)\n }\n \n @inlinable\n public func dispose() {\n self.force.dispose()\n }\n\n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics) {\n self.force.bindKinetics(kinetics)\n }\n}\n\npublic protocol ForceField2D: ForceField & Force2D {}\n\npublic protocol ForceField3D: ForceField & Force3D {}\n"
},
{
"path": "Sources/ForceSimulation/ForceSimulation.docc/CreatingASimulationWithBuiltinForces.md",
"content": "# Creating a Simulation with Built-in Forces\n\n\n\n## Overview\n\n\n\nYou can simply create simulations by using Simulation like this:\n\n```swift\nimport simd\nimport ForceSimulation\n\n// assuming you’re simulating 4 nodes\nlet nodeCount = 4 \n\n// Connect them\nlet links = [(0, 1), (1, 2), (2, 3), (3, 0)] \n\n/// Create a 2D force composited with 4 primitive forces.\nlet myForce = SealedForce2D {\n // Forces are namespaced under `Kinetics`\n // here we only use `Kinetics>`, i.e. `Kinetics2D`\n Kinetics2D.ManyBodyForce(strength: -30)\n Kinetics2D.LinkForce(\n stiffness: .weightedByDegree(k: { _, _ in 1.0 }),\n originalLength: .constant(35)\n )\n Kinetics2D.CenterForce(center: .zero, strength: 1)\n Kinetics2D.CollideForce(radius: .constant(3))\n}\n\n/// Create a simulation, the dimension is inferred from the force.\nlet mySimulation = Simulation(\n nodeCount: nodeCount,\n links: links.map { EdgeID(source: $0.0, target: $0.1) },\n forceField: myForce\n) \n\n/// Force is ready to start! run `tick` to iterate the simulation.\n\nfor mySimulation in 0..<120 {\n mySimulation.tick()\n let positions = mySimulation.kinetics.position.asArray()\n /// Do something with the positions.\n}\n```\n\nForceSimulation module mainly contains 3 concepts, `Kinetics`, `ForceProtocol` and `Simulation`.\n\n@Image(source: \"SimulationDiagram.svg\", alt: \"A diagram showing the relationships of `Kinetics`, `ForceProtocol` and `Simulation`. A `Simulation` contains a `Kinetics` and a `ForceProtocol`.\")\n\nA diagram showing the relationships of `Kinetics`, `ForceProtocol` and `Simulation`. A `Simulation` contains a `Kinetics` and a `ForceProtocol`.\n\n- `Kinetics` describes all kinetic states of your system, i.e. position, velocity, link connections, and the variable alpha that describes how \"active\" your system is. `Vector` tells simulation how you decribe a coordinate in this space, it can be `SIMD2` or `SIMD3` or any other types conforming to `SimulatableVector`. \n\n- Forces are any types that conforms to `ForceProtocol`. This module provides most of the forces you will use in force directed graphs. And you can also create your own forces. They should be responsible for 2 tasks:\n\n - `bindKinetics(_ kinetics: Kinetics)`: binding to a Kinetics. In most cases the force should keep a reference of the Kinetics so they know what to mutate when apply is called.\n\n - `apply()`: Mutating the states of Kinetics. For example, a gravity force should add velocities on each node in this function.\n\n- Simulation is a shell class you interact with, which enables you to create any dimensional simulation with velocity Verlet integration. It manages a Kinetics and a force conforming to ``ForceProtocol``. Since Simulation only stores one force, you are responsible for compositing multiple forces into one.\n\n- Another data structure ``KDTree`` is used to accelerate the force simulation with Barnes-Hut Approximation.\n\nIn this example, we run our simulation in a 2D space (`SIMD2`). We explicitly create a ``SealedForce2D`` to make sure the force is in the same dimension as the Kinetics. The `Vector` in `Simulation` is inferred from the force we pass.\n\nSee [Examples](https://github.com/swiftgraphs/Grape/tree/main/Examples) for example Xcode projects."
},
{
"path": "Sources/ForceSimulation/ForceSimulation.docc/Documentation.md",
"content": "# ``ForceSimulation``\n\nRun force simulation within any number of dimensions.\n\n## Overview\n\nThe `ForceSimulation` library enables you to create any dimensional simulation that uses velocity Verlet integration.\n\nIf you’re looking for an out-of-the-box SwiftUI View to render force-directed graphs, please refer to [Grape | Documentation](https://swiftgraphs.github.io/Grape/Grape/documentation/grape/).\n\n\n\n@Image(source: \"ForceDirectedGraph.png\", alt: \"An example of 2D force directied graph.\")\n\n\nFor more information on force simulations, read: [Force simulations - D3](https://d3js.org/d3-force/simulation). \n\n\n## Topics\n\n### Creating a simulation\n\n* \n\n* ``Simulation``\n* ``Kinetics``\n\n### Built-in forces\n\n* ``Kinetics/LinkForce``\n* ``Kinetics/ManyBodyForce``\n* ``Kinetics/CenterForce``\n* ``Kinetics/CollideForce``\n* ``Kinetics/PositionForce``\n* ``Kinetics/RadialForce``\n* ``Kinetics/EmptyForce``\n\n### Utility forces for compositing a force field\n\n* ``ForceField``\n* ``CompositedForce``\n* ``SealedForce2D``\n* ``SealedForce3D``\n\n\n\n### Spatial partitioning data structures\n\n- ``KDTree``\n- ``KDBox``\n- ``BufferedKDTree``\n- ``KDTreeDelegate``\n\n### Deterministic randomness\n\n\n- ``SimulatableFloatingPoint``\n- ``DeterministicRandomGenerator``\n- ``HasDeterministicRandomGenerator``\n- ``DoubleLinearCongruentialGenerator``\n- ``FloatLinearCongruentialGenerator``\n\n\n### Supporting protocols\n\n- ``ForceProtocol``\n- ``SimulatableVector``\n\n### Utilities\n\n- ``UnsafeArray``\n- ``EdgeID``\n- ``AttributeDescriptor``\n\n\n"
},
{
"path": "Sources/ForceSimulation/ForceSimulation.docc/theme-settings.json",
"content": "{\n \"theme\": {\n \"typography\": {\n \"html-font\": \"system-ui, -apple-system, \\\"InterVar\\\"\",\n \"html-font-mono\": \"ui-monospace, \\\"JetBrains Mono\\\", \\\"IBM Plex Mono\\\", monospace\"\n }\n }\n}"
},
{
"path": "Sources/ForceSimulation/Forces/CenterForce.swift",
"content": "extension Kinetics {\n /// A force that drives nodes towards the center.\n ///\n /// Center force is relatively fast, the complexity is `O(n)`,\n /// where `n` is the number of nodes.\n /// See [Collide Force - D3](https://d3js.org/d3-force/collide).\n public struct CenterForce: ForceProtocol {\n\n @inlinable\n public func apply(to kinetics: inout Kinetics) {\n var meanPosition = Vector.zero\n let positionBufferPointer = kinetics.position.mutablePointer\n for i in 0..: KDTreeDelegate\nwhere Vector: SimulatableVector {\n\n @usableFromInline\n var radiusBufferPointer: UnsafeMutablePointer\n\n public var maxNodeRadius: Vector.Scalar = .zero\n\n @inlinable\n public mutating func didAddNode(_ node: Int, at position: Vector) {\n maxNodeRadius = max(maxNodeRadius, radiusBufferPointer[node])\n }\n\n @inlinable\n public mutating func didRemoveNode(_ node: Int, at position: Vector) {\n if radiusBufferPointer[node] >= maxNodeRadius {\n // 🤯 for Collide force, set to 0 is fine\n // Otherwise you need to traverse the delegate again\n maxNodeRadius = 0\n }\n }\n\n @inlinable\n public func spawn() -> MaxRadiusNDTreeDelegate {\n return Self(radiusBufferPointer: radiusBufferPointer)\n }\n\n @inlinable\n init(maxNodeRadius: Vector.Scalar = 0, radiusBufferPointer: UnsafeMutablePointer)\n {\n self.maxNodeRadius = maxNodeRadius\n self.radiusBufferPointer = radiusBufferPointer\n }\n}\n\nextension Kinetics {\n\n public typealias CollideRadius = AttributeDescriptor\n\n /// A force that prevents nodes from overlapping.\n ///\n /// This is a very expensive force, the complexity is `O(n log(n))`,\n /// where `n` is the number of nodes.\n /// See [Collide Force - D3](https://d3js.org/d3-force/collide).\n public struct CollideForce: ForceProtocol {\n\n // @usableFromInline\n // var kinetics: Kinetics! = nil\n\n public var radius: CollideRadius\n\n public let iterationsPerTick: UInt\n public var strength: Vector.Scalar\n\n @inlinable\n public init(\n radius: CollideRadius,\n strength: Vector.Scalar = 1.0,\n iterationsPerTick: UInt = 1\n ) {\n self.radius = radius\n self.iterationsPerTick = iterationsPerTick\n self.strength = strength\n }\n\n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics) {\n // self.kinetics = kinetics\n self.calculatedRadius = self.radius.calculateUnsafe(for: kinetics.validCount)\n self.tree = .allocate(capacity: 1)\n self.tree.initialize(\n to:\n BufferedKDTree(\n rootBox: .init(\n p0: .init(repeating: 0),\n p1: .init(repeating: 1)\n ),\n nodeCapacity: kinetics.validCount,\n rootDelegate: .init(\n radiusBufferPointer: self.calculatedRadius.mutablePointer)\n )\n )\n }\n\n @usableFromInline\n var calculatedRadius: UnsafeArray! = nil\n\n @usableFromInline\n internal var tree:\n UnsafeMutablePointer>>! = nil\n\n @inlinable\n public func apply(to kinetics: inout Kinetics) {\n \n\n let strength = self.strength\n let calculatedRadius = self.calculatedRadius!.mutablePointer\n let positionBufferPointer = kinetics.position.mutablePointer\n let velocityBufferPointer = kinetics.velocity.mutablePointer\n\n let tree = self.tree!\n\n for _ in 0...cover(of: kinetics.position)\n\n tree.pointee.reset(\n rootBox: coveringBox,\n rootDelegate: .init(radiusBufferPointer: calculatedRadius)\n )\n assert(tree.pointee.validCount == 1)\n\n for p in kinetics.range {\n tree.pointee.add(nodeIndex: p, at: positionBufferPointer[p])\n }\n\n for i in kinetics.range {\n let iOriginalPosition = positionBufferPointer[i]\n let iOriginalVelocity = velocityBufferPointer[i]\n let iR = calculatedRadius[i]\n let iR2 = iR * iR\n let iPosition = iOriginalPosition + iOriginalVelocity\n\n tree.pointee.visit { t in\n\n let maxRadiusOfQuad = t.delegate.maxNodeRadius\n let deltaR = maxRadiusOfQuad + iR\n\n if var jNode = t.nodeIndices {\n while true {\n let j = jNode.index\n // print(\"\\(i)<=>\\(j)\")\n // is leaf, make sure every collision happens once.\n if j > i {\n\n let jR = calculatedRadius[j]\n let jOriginalPosition = positionBufferPointer[j]\n let jOriginalVelocity = velocityBufferPointer[j]\n var deltaPosition =\n iPosition - (jOriginalPosition + jOriginalVelocity)\n let l = (deltaPosition).lengthSquared()\n\n let deltaR = iR + jR\n if l < deltaR * deltaR {\n\n var l = /*simd_length*/ (deltaPosition.jiggled(by: &kinetics.randomGenerator))\n .length()\n l = (deltaR - l) / l * strength\n\n let jR2 = jR * jR\n\n let k = jR2 / (iR2 + jR2)\n\n deltaPosition *= l\n\n velocityBufferPointer[i] += deltaPosition * k\n velocityBufferPointer[j] -= deltaPosition * (1 - k)\n }\n }\n if jNode.next == nil {\n break\n } else {\n jNode = jNode.next!.pointee\n }\n }\n return false\n }\n\n // TODO: SIMD mask\n\n // for laneIndex in t.box.p0.indices {\n // let _v = t.box.p0[laneIndex]\n // if _v > iPosition[laneIndex] + deltaR /* True if no overlap */ {\n // return false\n // }\n // }\n\n // for laneIndex in t.box.p1.indices {\n // let _v = t.box.p1[laneIndex]\n // if _v < iPosition[laneIndex] - deltaR /* True if no overlap */ {\n // return false\n // }\n // }\n\n let p0Flag = t.box.p0 .> (iPosition + deltaR)\n let p1Flag = t.box.p1 .< (iPosition - deltaR)\n let flag = p0Flag .| p1Flag\n\n for laneIndex in t.box.p0.indices {\n if flag[laneIndex] {\n return false\n }\n // let _v = t.box.p1[laneIndex]\n // if (t.box.p0[laneIndex] > iPosition[laneIndex] + deltaR)\n // || (t.box.p1[laneIndex] < iPosition[laneIndex]\n // - deltaR) /* True if no overlap */\n // {\n // return false\n // }\n }\n return true\n }\n }\n }\n }\n\n /// Deinitialize the tree and deallocate the memory.\n /// Called when `Simulation` is deinitialized.\n @inlinable\n public func dispose() {\n self.tree.dispose()\n }\n\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/Forces/CompositedForce.swift",
"content": "/// Workaround for yet unsupported packed generic pack types & same type requirements\npublic struct CompositedForce: ForceProtocol\nwhere\n F1: ForceProtocol, F2: ForceProtocol,\n Vector: SimulatableVector & L2NormCalculatable,\n F1.Vector == Vector, F2.Vector == Vector, F1.Vector == Vector\n{\n\n @usableFromInline var force1: F1?\n @usableFromInline var force2: F2\n\n @inlinable\n public init(force1: F1? = nil, force2: F2) {\n self.force1 = force1\n self.force2 = force2\n }\n \n @inlinable\n public func apply(to kinetics: inout Kinetics) {\n self.force1?.apply(to: &kinetics)\n self.force2.apply(to: &kinetics)\n }\n \n @inlinable\n public func dispose() {\n self.force1?.dispose()\n self.force2.dispose()\n }\n \n \n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics) {\n self.force1?.bindKinetics(kinetics)\n self.force2.bindKinetics(kinetics)\n }\n\n @inlinable\n public init(@ForceBuilder _ builder: () -> CompositedForce) {\n self = builder()\n }\n}\n\n// public typealias CompositedForce2D = CompositedForce, F1, F2>\n// where F1: ForceProtocol>, F2: ForceProtocol>\n\n// public typealias CompositedForce3D = CompositedForce, F1, F2>\n// where F1: ForceProtocol>, F2: ForceProtocol>\n\n\n@resultBuilder\npublic struct ForceBuilder\nwhere Vector: SimulatableVector & L2NormCalculatable {\n\n public static func buildPartialBlock(first: F) -> F// CompositedForce.EmptyForce, F>\n where F: ForceProtocol, Vector: SimulatableVector & L2NormCalculatable {\n return first //.init(force2: first)\n }\n\n public static func buildPartialBlock(\n accumulated: F1,\n next: F2\n ) -> CompositedForce\n where\n F1: ForceProtocol, F2: ForceProtocol,\n Vector: SimulatableVector & L2NormCalculatable,\n F1.Vector == Vector, F2.Vector == Vector\n {\n return CompositedForce(force1: accumulated, force2: next)\n }\n\n public static func buildBlock(\n _ force1: F1? = nil,\n _ force2: F2\n ) -> CompositedForce\n where\n F1: ForceProtocol, F2: ForceProtocol,\n Vector: SimulatableVector & L2NormCalculatable,\n F1.Vector == Vector, F2.Vector == Vector\n {\n return CompositedForce(force1: force1, force2: force2)\n }\n\n\n public static func buildExpression(\n _ expression: Descriptor\n ) -> Descriptor.ConcreteForce {\n expression.createForce()\n }\n\n public static func buildExpression(\n _ expression: F\n ) -> F {\n expression\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/Forces/EmptyForce.swift",
"content": "extension Kinetics {\n\n public struct EmptyForce: ForceProtocol {\n \n\n @inlinable\n public func apply(to kinetics: inout Kinetics) {}\n\n @inlinable\n public func bindKinetics(_ kinetics: Kinetics) {}\n\n @inlinable\n public func dispose() {}\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/Forces/KDTreeForce.swift",
"content": "// public protocol KDTreeForce: ForceProtocol\n// where\n// Vector: SimulatableVector & L2NormCalculatable\n// {\n// associatedtype Delegate: KDTreeDelegate where Delegate.Vector == Vector, Delegate.NodeID == Int\n\n// var kinetics: Kinetics! { get set }\n\n// func epilogue()\n// func buildDelegate() -> Delegate\n// func visitForeignTree(\n// tree: inout KDTree, getDelegate: (D) -> Delegate)\n// }\n\n// public struct CompositedKDTreeDelegate: KDTreeDelegate\n// where\n// V: SimulatableVector & L2NormCalculatable,\n// D1: KDTreeDelegate, D2: KDTreeDelegate\n// {\n// var d1: D1\n// var d2: D2\n\n// mutating public func didAddNode(_ node: Int, at position: V) {\n// d1.didAddNode(node, at: position)\n// d2.didAddNode(node, at: position)\n// }\n\n// mutating public func didRemoveNode(_ node: Int, at position: V) {\n// d1.didRemoveNode(node, at: position)\n// d2.didRemoveNode(node, at: position)\n// }\n\n// public func spawn() -> CompositedKDTreeDelegate {\n// return .init(d1: d1.spawn(), d2: d2.spawn())\n// }\n\n// }\n\n// extension Kinetics.ManyBodyForce: KDTreeForce {\n// public typealias Delegate = MassCentroidKDTreeDelegate\n\n// public func epilogue() {\n\n// }\n\n// public func buildDelegate() -> MassCentroidKDTreeDelegate {\n// return .init(massProvider: { self.precalculatedMass[$0] })\n// }\n\n// public func visitForeignTree(\n// tree: inout KDTree, getDelegate: (D) -> MassCentroidKDTreeDelegate\n// ) {\n \n// }\n// }\n\n// extension Kinetics.CollideForce: KDTreeForce {\n// public typealias Delegate = MaxRadiusNDTreeDelegate\n\n// public func epilogue() {\n\n// }\n\n// public func buildDelegate() -> MaxRadiusNDTreeDelegate {\n// return .init(radiusProvider: { self.calculatedRadius[$0] })\n// }\n\n// public func visitForeignTree(\n// tree: inout KDTree, getDelegate: (D) -> MaxRadiusNDTreeDelegate\n// ) where D: KDTreeDelegate, Vector == D.Vector, D.NodeID == Int {\n\n// }\n// }\n\n// public struct CompositedKDTreeForce: ForceProtocol\n// where\n// KF1: KDTreeForce, KF2: KDTreeForce,\n// Vector: SimulatableVector & L2NormCalculatable,\n// KF1.Vector == Vector, KF2.Vector == Vector, KF1.Vector == Vector\n// {\n// var force1: KF1\n// var force2: KF2\n\n// public func apply() {\n// force1.epilogue()\n// force2.epilogue()\n\n// var tree = KDTree>(\n// covering: force1.kinetics!.position,\n// rootDelegate: CompositedKDTreeDelegate(\n// d1: force1.buildDelegate(),\n// d2: force2.buildDelegate()\n// )\n// )\n\n// force1.visitForeignTree(tree: &tree, getDelegate: \\.d1)\n// force2.visitForeignTree(tree: &tree, getDelegate: \\.d2)\n// }\n\n// public mutating func bindKinetics(_ kinetics: Kinetics) {\n\n// }\n\n// }\n"
},
{
"path": "Sources/ForceSimulation/Forces/LinkForce.swift",
"content": "import Darwin\n\nextension Kinetics {\n\n public enum LinkStiffness {\n case constant(Vector.Scalar)\n case varied((EdgeID, LinkLookup) -> Vector.Scalar)\n case weightedByDegree(k: (EdgeID, LinkLookup) -> Vector.Scalar)\n\n @inlinable\n func calculate(for link: [EdgeID], in lookup: LinkLookup) -> [Vector.Scalar] {\n switch self {\n case .constant(let m):\n return Array(repeating: m, count: link.count)\n case .varied(let f):\n return link.map { l in f(l, lookup) }\n case .weightedByDegree(let k):\n return link.map { l in\n k(l, lookup)\n / (Vector.Scalar(\n min(\n lookup.count[l.source, default: 0],\n lookup.count[l.target, default: 0]\n )\n ))\n }\n }\n }\n }\n\n public enum LinkLength {\n case constant(Vector.Scalar)\n case varied((EdgeID, LinkLookup) -> Vector.Scalar)\n\n @inlinable\n func calculate(for link: [EdgeID], in lookup: LinkLookup) -> [Vector.Scalar] {\n switch self {\n case .constant(let m):\n return Array(repeating: m, count: link.count)\n case .varied(let f):\n return link.map { l in f(l, lookup) }\n }\n }\n }\n\n /// A force that represents links between nodes.\n ///\n /// The complexity is `O(e)`, where `e` is the number of links.\n /// See [Link Force - D3](https://d3js.org/d3-force/link).\n public struct LinkForce: ForceProtocol {\n // @usableFromInline\n // internal var kinetics: Kinetics! = nil\n\n @usableFromInline\n var linkStiffness: LinkStiffness\n\n @usableFromInline\n var calculatedStiffness: [Vector.Scalar] = []\n\n @usableFromInline\n var linkLength: LinkLength\n\n @usableFromInline\n var calculatedLength: [Vector.Scalar] = []\n\n /// Bias\n @usableFromInline\n var calculatedBias: [Vector.Scalar] = []\n\n @inlinable\n public func apply(to kinetics: inout Kinetics) {\n let positionBufferPointer = kinetics.position.mutablePointer\n let velocityBufferPointer = kinetics.velocity.mutablePointer\n\n for _ in 0..]! = nil\n\n @usableFromInline\n internal var linkLookup: LinkLookup = .init(links: [])\n\n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics) {\n // self.kinetics = kinetics\n self.links = kinetics.links\n self.links = self.links.filter {\n $0.source < kinetics.validCount && $0.target < kinetics.validCount\n }\n self.linkLookup = .init(links: self.links)\n self.calculatedBias = self.links.map { l in\n Vector.Scalar(self.linkLookup.count[l.source, default: 0])\n / Vector.Scalar(\n linkLookup.count[l.target, default: 0]\n + linkLookup.count[l.source, default: 0])\n }\n\n self.calculatedStiffness = self.linkStiffness.calculate(\n for: self.links, in: self.linkLookup)\n self.calculatedLength = self.linkLength.calculate(for: self.links, in: self.linkLookup)\n }\n\n @usableFromInline var iterationsPerTick: UInt\n\n @inlinable\n public init(\n // _ links: [EdgeID],\n stiffness: LinkStiffness,\n originalLength: LinkLength = .constant(30),\n iterationsPerTick: UInt = 1\n ) {\n // self.links = links\n self.iterationsPerTick = iterationsPerTick\n self.linkStiffness = stiffness\n self.linkLength = originalLength\n\n }\n\n @inlinable\n public func dispose() {}\n }\n}\n\npublic struct LinkLookup {\n public let sourceToTarget: [NodeID: [NodeID]]\n public let targetToSource: [NodeID: [NodeID]]\n public let count: [NodeID: Int]\n\n @inlinable\n public init(links: [EdgeID]) {\n var sourceToTarget: [NodeID: [NodeID]] = [:]\n var targetToSource: [NodeID: [NodeID]] = [:]\n var count: [NodeID: Int] = [:]\n for link in links {\n sourceToTarget[link.source, default: []].append(link.target)\n targetToSource[link.target, default: []].append(link.source)\n count[link.source, default: 0] += 1\n count[link.target, default: 0] += 1\n }\n self.sourceToTarget = sourceToTarget\n self.targetToSource = targetToSource\n self.count = count\n }\n\n}\n\nextension Kinetics.LinkStiffness: Equatable {\n @inlinable\n public static func == (lhs: Kinetics.LinkStiffness, rhs: Kinetics.LinkStiffness) -> Bool {\n switch (lhs, rhs) {\n case (.constant(let l), .constant(let r)):\n return l == r\n default:\n return false\n }\n }\n}\n\nextension Kinetics.LinkLength: Equatable {\n @inlinable\n public static func == (lhs: Kinetics.LinkLength, rhs: Kinetics.LinkLength) -> Bool {\n switch (lhs, rhs) {\n case (.constant(let l), .constant(let r)):\n return l == r\n default:\n return false\n }\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/Forces/ManyBodyForce.swift",
"content": "import simd\n\npublic struct MassCentroidKDTreeDelegate: KDTreeDelegate\nwhere Vector: SimulatableVector {\n\n public var accumulatedMass: Vector.Scalar = .zero\n public var accumulatedCount: Int = 0\n public var accumulatedMassWeightedPositions: Vector = .zero\n\n @usableFromInline let massArray: UnsafeMutablePointer //(NodeID) -> Vector.Scalar\n\n @inlinable\n init(massProvider: UnsafeMutablePointer) {\n self.massArray = massProvider\n }\n\n @inlinable\n init(\n initialAccumulatedProperty: Vector.Scalar,\n initialAccumulatedCount: Int,\n initialWeightedAccumulatedNodePositions: Vector,\n massProvider: UnsafeMutablePointer //@escaping (Int) -> Vector.Scalar\n ) {\n self.accumulatedMass = initialAccumulatedProperty\n self.accumulatedCount = initialAccumulatedCount\n self.accumulatedMassWeightedPositions = initialWeightedAccumulatedNodePositions\n self.massArray = massProvider\n }\n\n @inlinable public mutating func didAddNode(_ node: Int, at position: Vector) {\n let p = massArray[node]\n #if DEBUG\n assert(p > 0)\n #endif\n accumulatedCount += 1\n accumulatedMass += p\n accumulatedMassWeightedPositions += position * p\n }\n\n @inlinable public mutating func didRemoveNode(_ node: Int, at position: Vector) {\n let p = massArray[node]\n accumulatedCount -= 1\n accumulatedMass -= p\n accumulatedMassWeightedPositions -= position * p\n // TODO: parent removal?\n }\n\n // @inlinable public func copy() -> Self {\n // return Self(\n // initialAccumulatedProperty: self.accumulatedMass,\n // initialAccumulatedCount: self.accumulatedCount,\n // initialWeightedAccumulatedNodePositions: self.accumulatedMassWeightedPositions,\n // massProvider: self.massProvider\n // )\n // }\n\n @inlinable public func spawn() -> Self {\n return Self(massProvider: self.massArray)\n }\n}\n\nextension Kinetics {\n public typealias NodeMass = AttributeDescriptor\n\n /// A force that simulate the many-body force.\n ///\n /// This is a very expensive force, the complexity is `O(n log(n))`,\n /// where `n` is the number of nodes. The complexity might degrade to `O(n^2)` if the nodes are too close to each other.\n /// See [Manybody Force - D3](https://d3js.org/d3-force/many-body).\n public struct ManyBodyForce: ForceProtocol {\n\n @usableFromInline let strength: Vector.Scalar\n @usableFromInline var theta2: Vector.Scalar\n @usableFromInline var theta: Vector.Scalar {\n didSet {\n theta2 = theta * theta\n }\n }\n @usableFromInline let distanceMin: Vector.Scalar = 1\n @usableFromInline let distanceMin2: Vector.Scalar = 1\n @usableFromInline let distanceMax2: Vector.Scalar = .infinity\n @usableFromInline let distanceMax: Vector.Scalar = .infinity\n\n public let mass: NodeMass\n @usableFromInline var precalculatedMass: UnsafeArray! = nil\n\n @inlinable\n public init(\n strength: Vector.Scalar,\n nodeMass: NodeMass = .constant(1.0),\n theta: Vector.Scalar = 0.9\n ) {\n self.strength = strength\n self.mass = nodeMass\n self.theta = theta\n self.theta2 = theta * theta\n\n }\n \n\n\n\n @inlinable\n public func apply(to kinetics: inout Kinetics) {\n \n // Avoid capturing self\n let alpha = kinetics.alpha\n let theta2 = self.theta2\n let distanceMin2 = self.distanceMin2\n let distanceMax2 = self.distanceMax2\n let strength = self.strength\n let precalculatedMass = self.precalculatedMass.mutablePointer\n let positionBufferPointer = kinetics.position.mutablePointer\n // let random = kinetics.randomGenerator\n let tree = self.tree!\n\n let coveringBox = KDBox.cover(of: kinetics.position)\n tree.pointee.reset(rootBox: coveringBox, rootDelegate: .init(massProvider: precalculatedMass))\n for p in kinetics.range {\n tree.pointee.add(nodeIndex: p, at: positionBufferPointer[p])\n }\n\n for i in kinetics.range {\n let pos = positionBufferPointer[i]\n var f = Vector.zero\n tree.pointee.visit { t in\n\n guard t.delegate.accumulatedCount > 0 else { return false }\n let centroid =\n t.delegate.accumulatedMassWeightedPositions / t.delegate.accumulatedMass\n\n let vec = centroid - pos\n let boxWidth = (t.box.p1 - t.box.p0)[0]\n var distanceSquared =\n (vec\n .jiggled(by: &kinetics.randomGenerator)).lengthSquared()\n\n let farEnough: Bool =\n (distanceSquared * theta2) > (boxWidth * boxWidth)\n\n if distanceSquared < distanceMin2 {\n distanceSquared = (distanceMin2 * distanceSquared).squareRoot()\n }\n\n if farEnough {\n\n guard distanceSquared < distanceMax2 else { return true }\n\n /// Workaround for \"The compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions\"\n let k: Vector.Scalar =\n strength * alpha * t.delegate.accumulatedMass\n / distanceSquared // distanceSquared.squareRoot()\n\n f += vec * k\n return false\n\n } else if t.childrenBufferPointer != nil {\n return true\n }\n\n if t.isFilledLeaf {\n\n if t.nodeIndices!.contains(i) { return false }\n\n let massAcc = t.delegate.accumulatedMass\n\n let k: Vector.Scalar = strength * alpha * massAcc / distanceSquared // distanceSquared.squareRoot()\n f += vec * k\n return false\n } else {\n return true\n }\n }\n\n positionBufferPointer[i] += f / precalculatedMass[i]\n }\n }\n\n // public var kinetics: Kinetics! = nil\n\n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics) {\n // self.kinetics = kinetics\n self.precalculatedMass = self.mass.calculateUnsafe(for: (kinetics.validCount))\n\n self.tree = .allocate(capacity: 1)\n self.tree.initialize(\n to:\n BufferedKDTree(\n rootBox: .init(\n p0: .init(repeating: 0),\n p1: .init(repeating: 1)\n ),\n nodeCapacity: kinetics.validCount,\n rootDelegate: MassCentroidKDTreeDelegate(\n massProvider: precalculatedMass.mutablePointer)\n )\n )\n }\n\n /// The buffered KDTree used across all ticks.\n @usableFromInline\n internal var tree:\n UnsafeMutablePointer>>! = nil\n \n /// Deinitialize the tree and deallocate the memory.\n /// Called when `Simulation` is deinitialized.\n @inlinable\n public func dispose() {\n self.tree.deinitialize(count: 1)\n self.tree.deallocate()\n }\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/Forces/PackedForce.swift",
"content": "// struct PackedForce: ForceProtocol where Vector: SIMD, Vector.Scalar: FloatingPoint, repeat each Force: ForceProtocol {\n// let forces: (repeat each Force)\n\n// // var kinetics: Kinetics?\n\n// init(forces: repeat each Force) {\n// self.forces = (repeat each forces)\n// }\n\n// func apply() {\n// repeat (each forces).apply()\n// }\n\n// func bindKinetics(_ kinetics: Kinetics) {\n// repeat (each forces).bindKinetics(kinetics)\n// }\n// }"
},
{
"path": "Sources/ForceSimulation/Forces/PositionForce.swift",
"content": "extension Kinetics {\n\n public typealias TargetOnDirection = AttributeDescriptor\n public enum DirectionOfPositionForce: Equatable {\n case x\n case y\n case z\n case entryOfVector(Int)\n }\n public typealias PositionStrength = AttributeDescriptor\n\n /// A force that moves nodes to a target position.\n ///\n /// Center force is relatively fast, the complexity is `O(n)`,\n /// where `n` is the number of nodes.\n /// See [Position Force - D3](https://d3js.org/d3-force/position).\n public struct PositionForce: ForceProtocol {\n\n // @usableFromInline var kinetics: Kinetics! = nil\n\n public var strength: PositionStrength\n public var direction: Int\n public var calculatedStrength: UnsafeArray! = nil\n public var targetOnDirection: TargetOnDirection\n public var calculatedTargetOnDirection: UnsafeArray! = nil\n\n @inlinable\n public func apply(to kinetics: inout Kinetics) {\n let alpha = kinetics.alpha\n let lane = self.direction\n for i in kinetics.range {\n kinetics.velocity[i][lane] +=\n (self.calculatedTargetOnDirection[i] - kinetics.position[i][lane])\n * self.calculatedStrength[i] * alpha\n }\n }\n\n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics) {\n // self.kinetics = kinetics\n self.calculatedTargetOnDirection = self.targetOnDirection.calculateUnsafe(\n for: kinetics.validCount)\n self.calculatedStrength = self.strength.calculateUnsafe(for: kinetics.validCount)\n }\n\n @inlinable\n public init(\n direction: DirectionOfPositionForce,\n targetOnDirection: TargetOnDirection,\n strength: PositionStrength = .constant(1.0)\n ) {\n self.strength = strength\n self.direction = direction.lane\n self.targetOnDirection = targetOnDirection\n }\n\n @inlinable\n public func dispose() {}\n }\n\n}\n\nextension Kinetics.DirectionOfPositionForce {\n @inlinable\n var lane: Int {\n switch self {\n case .x: return 0\n case .y: return 1\n case .z: return 2\n case .entryOfVector(let i): return i\n }\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/Forces/RadialForce.swift",
"content": "extension Kinetics {\n\n public typealias RadialBound = AttributeDescriptor\n public typealias RadialStrength = AttributeDescriptor\n\n /// A force that applies a radial force to all nodes.\n ///\n /// Center force is relatively fast, the complexity is `O(n)`,\n /// where `n` is the number of nodes.\n /// See [Position Force - D3](https://d3js.org/d3-force/position).\n public struct RadialForce: ForceProtocol {\n\n // @usableFromInline var kinetics: Kinetics! = nil\n public var radius: RadialBound\n public var strength: RadialStrength\n public var center: Vector\n\n @usableFromInline\n var calculatedRadius: UnsafeArray! = nil\n\n @usableFromInline\n var calculatedStrength: UnsafeArray! = nil\n\n\n @inlinable\n public func apply(to kinetics: inout Kinetics) {\n let alpha = kinetics.alpha\n for i in kinetics.range {\n let deltaPosition = (kinetics.position[i] - self.center).jiggled(\n by: &kinetics.randomGenerator) //.jiggled()\n let r = deltaPosition.length()\n let k =\n (self.calculatedRadius[i]\n * self.calculatedStrength[i] * alpha) / r\n kinetics.velocity[i] += deltaPosition * k\n }\n }\n\n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics) {\n // self.kinetics = kinetics\n self.calculatedRadius = self.radius.calculateUnsafe(for: kinetics.validCount)\n self.calculatedStrength = self.strength.calculateUnsafe(for: kinetics.validCount)\n }\n\n @inlinable\n public init(center: Vector, radius: RadialBound, strength: RadialStrength) {\n self.center = center\n self.radius = radius\n self.strength = strength\n }\n\n @inlinable\n public func dispose() {}\n }\n\n}\n"
},
{
"path": "Sources/ForceSimulation/Forces/SealedForce2D.swift",
"content": "\n/// A force that can be composed of one or multiple forces. The forces you can add\n/// here include:\n/// - `Kinetics2D.CenterForce`\n/// - `Kinetics2D.RadialForce`\n/// - `Kinetics2D.ManyBodyForce`\n/// - `Kinetics2D.LinkForce`\n/// - `Kinetics2D.CollideForce`\n/// - `Kinetics2D.PositionForce`\n/// - `Kinetics2D.EmptyForce`\n/// \n/// If you want to add a custom force, checkout `CompositedForce`.\npublic struct SealedForce2D: Force2D {\n\n public var entries: [ForceEntry] = []\n\n @inlinable\n public func apply(to kinetics: inout Kinetics>) {\n for force in self.entries {\n force.apply(to: &kinetics)\n }\n }\n \n @inlinable\n public func dispose() {\n for force in self.entries {\n force.dispose()\n }\n }\n\n @inlinable\n public init(\n _ entries: [ForceEntry]\n ) {\n self.entries = entries\n }\n\n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics>) {\n self.entries = self.entries.map { entry in\n switch entry {\n case .center(var force):\n force.bindKinetics(kinetics)\n return .center(force)\n case .radial(var force):\n force.bindKinetics(kinetics)\n return .radial(force)\n case .manyBody(var force):\n force.bindKinetics(kinetics)\n return .manyBody(force)\n case .link(var force):\n force.bindKinetics(kinetics)\n return .link(force)\n case .collide(var force):\n force.bindKinetics(kinetics)\n return .collide(force)\n case .position(var force):\n force.bindKinetics(kinetics)\n return .position(force)\n default:\n return entry\n }\n }\n }\n\n public enum ForceEntry {\n case center(Kinetics2D.CenterForce)\n case radial(Kinetics2D.RadialForce)\n case manyBody(Kinetics2D.ManyBodyForce)\n case link(Kinetics2D.LinkForce)\n case collide(Kinetics2D.CollideForce)\n case position(Kinetics2D.PositionForce)\n case empty\n\n @inlinable\n public func dispose() {\n switch self {\n case .center(let force):\n force.dispose()\n case .radial(let force):\n force.dispose()\n case .manyBody(let force):\n force.dispose()\n case .link(let force):\n force.dispose()\n case .collide(let force):\n force.dispose()\n case .position(let force):\n force.dispose()\n default:\n break\n }\n }\n\n\n @inlinable\n public func apply(to kinetics: inout Kinetics>) {\n switch self {\n case .center(let force):\n force.apply(to: &kinetics)\n case .radial(let force):\n force.apply(to: &kinetics)\n case .manyBody(let force):\n force.apply(to: &kinetics)\n case .link(let force):\n force.apply(to: &kinetics)\n case .collide(let force):\n force.apply(to: &kinetics)\n case .position(let force):\n force.apply(to: &kinetics)\n default:\n break\n }\n }\n }\n\n @inlinable\n public init(@SealedForce2DBuilder _ builder: () -> [ForceEntry]) {\n self.entries = builder()\n }\n\n}\n\n\n@resultBuilder\npublic struct SealedForce2DBuilder {\n public static func buildBlock(_ components: SealedForce2D.ForceEntry...) -> [SealedForce2D.ForceEntry] {\n components\n }\n\n public static func buildExpression(_ expression: FD) -> SealedForce2D.ForceEntry where FD: ForceDescriptor, FD.ConcreteForce: Force2D {\n let f = expression.createForce()\n switch f {\n case let f as Kinetics2D.CenterForce:\n return .center(f)\n case let f as Kinetics2D.RadialForce:\n return .radial(f)\n case let f as Kinetics2D.ManyBodyForce:\n return .manyBody(f)\n case let f as Kinetics2D.LinkForce:\n return .link(f)\n case let f as Kinetics2D.CollideForce:\n return .collide(f)\n case let f as Kinetics2D.PositionForce:\n return .position(f)\n default:\n return .empty\n }\n }\n\n public static func buildExpression(_ f: F) -> SealedForce2D.ForceEntry where F:Force2D {\n switch f {\n case let f as Kinetics2D.CenterForce:\n return .center(f)\n case let f as Kinetics2D.RadialForce:\n return .radial(f)\n case let f as Kinetics2D.ManyBodyForce:\n return .manyBody(f)\n case let f as Kinetics2D.LinkForce:\n return .link(f)\n case let f as Kinetics2D.CollideForce:\n return .collide(f)\n case let f as Kinetics2D.PositionForce:\n return .position(f)\n default:\n return .empty\n }\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/Forces/SealedForce3D.swift",
"content": "\n/// A force that can be composed of one or multiple forces. The forces you can add\n/// here include:\n/// - `Kinetics3D.CenterForce`\n/// - `Kinetics3D.RadialForce`\n/// - `Kinetics3D.ManyBodyForce`\n/// - `Kinetics3D.LinkForce`\n/// - `Kinetics3D.CollideForce`\n/// - `Kinetics3D.PositionForce`\n/// - `Kinetics3D.EmptyForce`\n/// \n/// If you want to add a custom force, checkout `CompositedForce`.\npublic struct SealedForce3D: Force3D {\n\n public var entries: [ForceEntry] = []\n\n\n @inlinable\n public func apply(to kinetics: inout Kinetics>) {\n for force in self.entries {\n force.apply(to: &kinetics)\n }\n }\n \n @inlinable\n public func dispose() {\n for force in self.entries {\n force.dispose()\n }\n }\n\n @inlinable\n public init(\n _ entries: [ForceEntry]\n ) {\n self.entries = entries\n }\n\n @inlinable\n public mutating func bindKinetics(_ kinetics: Kinetics>) {\n self.entries = self.entries.map { entry in\n switch entry {\n case .center(var force):\n force.bindKinetics(kinetics)\n return .center(force)\n case .radial(var force):\n force.bindKinetics(kinetics)\n return .radial(force)\n case .manyBody(var force):\n force.bindKinetics(kinetics)\n return .manyBody(force)\n case .link(var force):\n force.bindKinetics(kinetics)\n return .link(force)\n case .collide(var force):\n force.bindKinetics(kinetics)\n return .collide(force)\n case .position(var force):\n force.bindKinetics(kinetics)\n return .position(force)\n default:\n return entry\n }\n }\n }\n\n public enum ForceEntry {\n case center(Kinetics3D.CenterForce)\n case radial(Kinetics3D.RadialForce)\n case manyBody(Kinetics3D.ManyBodyForce)\n case link(Kinetics3D.LinkForce)\n case collide(Kinetics3D.CollideForce)\n case position(Kinetics3D.PositionForce)\n case empty\n\n @inlinable\n public func dispose() {\n switch self {\n case .center(let force):\n force.dispose()\n case .radial(let force):\n force.dispose()\n case .manyBody(let force):\n force.dispose()\n case .link(let force):\n force.dispose()\n case .collide(let force):\n force.dispose()\n case .position(let force):\n force.dispose()\n default:\n break\n }\n }\n\n @inlinable\n public func apply(to kinetics: inout Kinetics>) {\n switch self {\n case .center(let force):\n force.apply(to: &kinetics)\n case .radial(let force):\n force.apply(to: &kinetics)\n case .manyBody(let force):\n force.apply(to: &kinetics)\n case .link(let force):\n force.apply(to: &kinetics)\n case .collide(let force):\n force.apply(to: &kinetics)\n case .position(let force):\n force.apply(to: &kinetics)\n default:\n break\n }\n }\n }\n\n @inlinable\n public init(@SealedForce3DBuilder _ builder: () -> [ForceEntry]) {\n self.entries = builder()\n }\n\n}\n\n\n@resultBuilder\npublic struct SealedForce3DBuilder {\n public static func buildBlock(_ components: SealedForce3D.ForceEntry...) -> [SealedForce3D.ForceEntry] {\n components\n }\n\n public static func buildExpression(_ expression: FD) -> SealedForce3D.ForceEntry where FD: ForceDescriptor, FD.ConcreteForce: Force3D {\n let f = expression.createForce()\n switch f {\n case let f as Kinetics3D.CenterForce:\n return .center(f)\n case let f as Kinetics3D.RadialForce:\n return .radial(f)\n case let f as Kinetics3D.ManyBodyForce:\n return .manyBody(f)\n case let f as Kinetics3D.LinkForce:\n return .link(f)\n case let f as Kinetics3D.CollideForce:\n return .collide(f)\n case let f as Kinetics3D.PositionForce:\n return .position(f)\n default:\n return .empty\n }\n }\n\n public static func buildExpression(_ f: F) -> SealedForce3D.ForceEntry where F:Force3D {\n switch f {\n case let f as Kinetics3D.CenterForce:\n return .center(f)\n case let f as Kinetics3D.RadialForce:\n return .radial(f)\n case let f as Kinetics3D.ManyBodyForce:\n return .manyBody(f)\n case let f as Kinetics3D.LinkForce:\n return .link(f)\n case let f as Kinetics3D.CollideForce:\n return .collide(f)\n case let f as Kinetics3D.PositionForce:\n return .position(f)\n default:\n return .empty\n }\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/KDTree/BufferedKDTree.swift",
"content": "public struct BufferedKDTree: Disposable\nwhere\n Vector: SimulatableVector & L2NormCalculatable,\n Delegate: KDTreeDelegate\n{\n public typealias Box = KDBox\n public typealias TreeNode = KDTreeNode\n\n @usableFromInline\n internal var rootPointer: UnsafeMutablePointer {\n treeNodeBuffer.mutablePointer\n }\n\n @usableFromInline\n internal var validCount: Int = 0\n\n @usableFromInline\n internal var treeNodeBuffer: UnsafeArray\n\n @inlinable\n static internal var clusterDistanceSquared: Vector.Scalar {\n return Vector.clusterDistanceSquared\n }\n\n @inlinable\n public var root: TreeNode { rootPointer.pointee }\n\n @inlinable\n public init(\n rootBox: Box,\n nodeCapacity: Int,\n rootDelegate: @autoclosure () -> Delegate\n ) {\n // Assuming each add creates 2^Vector.scalarCount nodes\n // In most situations this is sufficient (for example the miserable graph)\n // But It's possible to exceed this limit:\n // 2 additions very close but not clustered in the same box\n // In this case there's no upperbound for addition so `resize` is needed\n let maxBufferCount = (nodeCapacity << Vector.scalarCount) + 1\n self.rootDelegate = rootDelegate()\n\n treeNodeBuffer = .createBuffer(\n withHeader: maxBufferCount,\n count: maxBufferCount,\n initialValue: .zeroWithDelegate(self.rootDelegate)\n )\n rootPointer.pointee = TreeNode(\n nodeIndices: nil,\n childrenBufferPointer: nil,\n delegate: self.rootDelegate,\n box: rootBox\n )\n self.validCount = 1\n }\n\n @usableFromInline\n internal var rootDelegate: Delegate\n\n @inlinable\n public mutating func reset(\n rootBox: Box,\n rootDelegate: @autoclosure () -> Delegate\n ) {\n self.rootDelegate = rootDelegate()\n\n treeNodeBuffer.withUnsafeMutablePointerToElements {\n for i in 0.. treeNodeBuffer.header)\n let rootCopy = root\n #endif\n let oldRootPointer = rootPointer\n\n let newTreeNodeBuffer = UnsafeArray.createBuffer(\n withHeader: newTreeNodeBufferSize,\n count: newTreeNodeBufferSize,\n moving: treeNodeBuffer.mutablePointer,\n movingCount: validCount,\n fillingExcessiveBufferWith: .zeroWithDelegate(self.rootDelegate)\n )\n\n let newRootPointer = newTreeNodeBuffer.withUnsafeMutablePointerToElements { $0 }\n\n for i in 0.. Bool {\n if validCount + count > treeNodeBuffer.count {\n let factor = (count / self.treeNodeBuffer.count) + 2\n\n resize(to: treeNodeBuffer.count * factor)\n\n assert(treeNodeBuffer.count >= validCount + count)\n\n return true\n }\n return false\n }\n\n @inlinable\n public mutating func add(\n nodeIndex: Int,\n at point: Vector\n ) {\n assert(validCount > 0)\n cover(point: point)\n addWithoutCover(\n onTreeNode: rootPointer,\n nodeOf: nodeIndex,\n at: point\n )\n }\n\n @inlinable\n internal mutating func addWithoutCover(\n onTreeNode treeNode: UnsafeMutablePointer,\n nodeOf nodeIndex: Int,\n at point: Vector\n ) {\n if treeNode.pointee.childrenBufferPointer != nil {\n\n let directionOfNewNode = getIndexInChildren(\n point, relativeTo: treeNode.pointee.box.center)\n let treeNodeOffset = (treeNode) - rootPointer\n self.addWithoutCover(\n onTreeNode: treeNode.pointee.childrenBufferPointer! + directionOfNewNode,\n nodeOf: nodeIndex,\n at: point\n )\n rootPointer[treeNodeOffset].delegate.didAddNode(nodeIndex, at: point)\n return\n\n } else if treeNode.pointee.nodeIndices == nil {\n // empty leaf\n\n treeNode.pointee.nodeIndices = TreeNode.NodeIndex(nodeIndex)\n treeNode.pointee.nodePosition = point\n treeNode.pointee.delegate.didAddNode(nodeIndex, at: point)\n\n return\n } else if treeNode.pointee.nodePosition.distanceSquared(to: point)\n > Self.clusterDistanceSquared\n {\n // filled leaf\n\n let treeNodeOffset = (treeNode) - rootPointer\n resizeIfNeededBeforeAllocation(for: Self.directionCount)\n \n let newTreeNode = self.rootPointer + treeNodeOffset\n \n let spawnedDelegate = newTreeNode.pointee.delegate.spawn()\n let center = newTreeNode.pointee.box.center\n\n let _box = newTreeNode.pointee.box\n for j in 0..> i) & 0b1\n if isOnTheHigherRange != 0 {\n __box.p0[i] = center[i]\n } else {\n __box.p1[i] = center[i]\n }\n }\n\n let obsoletePtr = self.rootPointer + validCount + j\n\n obsoletePtr.pointee.disposeNodeIndices()\n obsoletePtr.pointee = TreeNode(\n nodeIndices: nil,\n childrenBufferPointer: nil,\n delegate: spawnedDelegate,\n box: __box\n )\n\n }\n newTreeNode.pointee.childrenBufferPointer = rootPointer + validCount\n validCount += Self.directionCount\n\n if let childrenBufferPointer = newTreeNode.pointee.childrenBufferPointer {\n let direction = getIndexInChildren(\n newTreeNode.pointee.nodePosition,\n relativeTo: center\n )\n // newly created, no need to dispose\n // childrenBufferPointer[direction].disposeNodeIndices()\n childrenBufferPointer[direction] = .init(\n nodeIndices: newTreeNode.pointee.nodeIndices,\n childrenBufferPointer: childrenBufferPointer[direction]\n .childrenBufferPointer,\n delegate: newTreeNode.pointee.delegate,\n box: childrenBufferPointer[direction].box,\n nodePosition: newTreeNode.pointee.nodePosition\n )\n\n newTreeNode.pointee.nodeIndices = nil\n newTreeNode.pointee.nodePosition = .zero\n }\n\n let directionOfNewNode = getIndexInChildren(point, relativeTo: center)\n\n // This add might also resize this buffer!\n addWithoutCover(\n onTreeNode: newTreeNode.pointee.childrenBufferPointer! + directionOfNewNode,\n nodeOf: nodeIndex,\n at: point\n )\n\n rootPointer[treeNodeOffset].delegate.didAddNode(nodeIndex, at: point)\n return\n } else {\n // filled leaf and within cluster distance\n treeNode.pointee.nodeIndices!.append(nodeIndex: nodeIndex)\n\n treeNode.pointee.delegate.didAddNode(nodeIndex, at: point)\n return\n }\n\n }\n\n @inlinable\n internal mutating func cover(point: Vector) {\n if self.root.box.contains(point) { return }\n\n repeat {\n let direction = self.getIndexInChildren(point, relativeTo: self.root.box.p0)\n self.expand(towards: direction)\n } while !self.root.box.contains(point)\n }\n\n @inlinable\n internal mutating func expand(towards direction: Int) {\n let nailedDirection = (Self.directionCount - 1) - direction\n let nailedCorner = self.root.box.getCorner(of: nailedDirection)\n let _corner = self.root.box.getCorner(of: direction)\n let expandedCorner = (_corner + _corner) - nailedCorner\n let newRootBox = Box(nailedCorner, expandedCorner)\n\n let _rootValue = self.root\n\n // spawn the delegate with the same internal values\n // for the children, use implicit copy of spawned\n let spawned = _rootValue.delegate.spawn()\n\n let newChildrenPointer = self.rootPointer + validCount\n\n resizeIfNeededBeforeAllocation(for: Self.directionCount)\n\n for j in 0..> i) & 0b1\n // TODO: use simd mask\n if isOnTheHigherRange != 0 {\n __box.p0[i] = _corner[i]\n } else {\n __box.p1[i] = _corner[i]\n }\n }\n // newly allocated, no need to dispose\n if j != nailedDirection {\n self.treeNodeBuffer[validCount + j] = TreeNode(\n nodeIndices: nil,\n childrenBufferPointer: nil,\n delegate: spawned,\n box: __box,\n nodePosition: .zero\n )\n } else {\n self.treeNodeBuffer[validCount + j] = TreeNode(\n nodeIndices: _rootValue.nodeIndices,\n childrenBufferPointer: _rootValue.childrenBufferPointer,\n delegate: _rootValue.delegate,\n box: __box,\n nodePosition: _rootValue.nodePosition\n )\n }\n }\n self.validCount += Self.directionCount\n\n // don't dispose, they are used in treeNodeBuffer[validCount + j]\n self.rootPointer.pointee = .init(\n nodeIndices: nil,\n childrenBufferPointer: newChildrenPointer,\n delegate: _rootValue.delegate,\n box: newRootBox\n )\n }\n\n @inlinable\n static internal var directionCount: Int { 1 << Vector.scalarCount }\n\n @inlinable\n public func dispose() {\n treeNodeBuffer.withUnsafeMutablePointerToElements {\n for i in 0.. Int {\n var index = 0\n let mask = point .>= originalPoint\n\n for i in 0..) -> Bool\n ) {\n rootPointer.pointee.visit(shouldVisitChildren: shouldVisitChildren)\n }\n}\n"
},
{
"path": "Sources/ForceSimulation/KDTree/KDBox.swift",
"content": "//\n// KDBox.swift\n//\n//\n// Created by li3zhen1 on 10/14/23.\n//\nimport simd\n\n/// A box in N-dimensional space.\n///\n/// - Note: `p0` is the minimum point of the box, `p1` is the maximum point of the box.\npublic struct KDBox: Equatable\nwhere V: SIMD, V.Scalar: FloatingPoint & ExpressibleByFloatLiteral {\n /// the minimum anchor of the box\n public var p0: V\n\n /// the maximum anchor of the box\n public var p1: V\n\n /// Create a box with 2 anchors.\n ///\n /// - Parameters:\n /// - p0: anchor\n /// - p1: another anchor in the diagonal position of `p0`\n /// - Note: `p0` you pass does not have to be minimum point of the box.\n /// `p1` does not have to be maximum point of the box. The initializer will\n /// automatically adjust the order of `p0` and `p1` to make sure `p0` is the\n /// minimum point of the box and `p1` is the maximum point of the box.\n @inlinable\n public init(p0: V, p1: V) {\n // #if DEBUG\n assert(p0 != p1, \"NdBox was initialized with 2 same anchor\")\n // #endif\n // var p0 = p0\n // var p1 = p1\n\n // for i in p0.indices {\n // if p1[i] < p0[i] {\n // swap(&p0[i], &p1[i])\n // }\n // }\n // let mask = p0 .< p1\n // self.p0 = p1.replacing(with: p0, where: mask)\n // self.p1 = p0.replacing(with: p1, where: mask)\n self.p0 = pointwiseMin(p0, p1)\n self.p1 = pointwiseMax(p0, p1)\n // TODO: use Mask\n }\n\n /// Create a box with 2 anchors.\n ///\n /// - Parameters:\n /// - pMin: minimum anchor of the box\n /// - pMax: maximum anchor of the box\n /// - Note: Please make sure `pMin` is the minimum point of the box and `pMax` is the\n /// maximum point of the box.\n @inlinable\n @available(*, deprecated, renamed: \"init(uncheckedP0:uncheckedP1:)\")\n internal init(pMin: V, pMax: V) {\n assert(pMin != pMax, \"NdBox was initialized with 2 same anchor\")\n self.p0 = pMin\n self.p1 = pMax\n }\n\n @inlinable\n internal init(uncheckedP0: V, uncheckedP1: V) {\n self.p0 = uncheckedP0\n self.p1 = uncheckedP1\n }\n\n /// Create a box with 2 zero anchors.\n @inlinable\n @available(*, deprecated, renamed: \"zero\")\n public init() {\n p0 = .zero\n p1 = .zero\n }\n\n /// Create a box with 2 anchors.\n /// - Parameters:\n /// - p0: anchor\n /// - p1: another anchor in the diagonal position of `p0`\n /// - Note: `p0` you pass does not have to be minimum point of the box.\n /// `p1` does not have to be maximum point of the box. The initializer will\n /// automatically adjust the order of `p0` and `p1` to make sure `p0` is the\n /// minimum point of the box and `p1` is the maximum point of the box.\n @inlinable\n public init(_ p0: V, _ p1: V) {\n self.init(p0: p0, p1: p1)\n }\n\n}\n\nextension KDBox {\n @inlinable\n @inline(__always)\n var diagnalVector: V {\n return p1 - p0\n }\n\n @inlinable\n static var zero: Self {\n return Self(uncheckedP0: .zero, uncheckedP1: .zero)\n }\n\n @inlinable \n @inline(__always)\n var center: V { (p1 + p0) / 2.0 }\n\n /// Test if the box contains a point.\n /// - Parameter point: N dimensional point\n /// - Returns: `true` if the box contains the point, `false` otherwise.\n /// The boundary test is similar to ..< operator.\n @inlinable \n @inline(__always)\n func contains(_ point: V) -> Bool {\n // let mask = \n return !any((p0 .> point) .| (point .>= p1))\n //mask == .init(repeating: false)\n\n // equivalent to:\n // for i in point.indices {\n // if p0[i] > point[i] || point[i] >= p1[i] {\n // return false\n // }\n // }\n // return true\n }\n}\n\nextension KDBox {\n\n @inlinable func getCorner(of direction: Int) -> V {\n var mask = SIMDMask()\n\n for i in 0..> i) & 0b1) == 1\n }\n return p0.replacing(with: p1, where: mask)\n\n // equivalent to:\n // var corner = V.zero\n // for i in 0..> i) & 0b1) == 1 ? p1[i] : p0[i]\n // }\n // return p0.replacing(with: p1, where: mask) //corner\n }\n\n // @inlinable public var debugDescription: String {\n // return \"[\\(p0), \\(p1)]\"\n // }\n}\n\nextension KDBox {\n\n /// Get the small box that contains a list points and guarantees the box's size is at least 1x..x1.\n ///\n /// - Parameter points: The points to be covered.\n /// - Returns: The box that contains all the points.\n @inlinable public static func cover(of points: [V]) -> Self {\n\n var _p0 = points[0]\n var _p1 = points[0]\n\n for p in points {\n // let mask1 = p .< _p0\n // let mask2 = p .>= _p1\n\n // _p0 = _p0.replacing(with: p, where: mask1)\n // _p1 = _p1.replacing(with: p + 1, where: mask2)\n\n _p0 = pointwiseMin(p, _p0)\n _p1 = pointwiseMax(p, _p1)\n\n // for i in p.indices {\n // if p[i] < _p0[i] {\n // _p0[i] = p[i]\n // }\n // if p[i] >= _p1[i] {\n // _p1[i] = p[i] + 1\n // }\n // }\n }\n\n #if DEBUG\n let _box = Self(_p0, _p1)\n assert(\n points.allSatisfy { p in\n _box.contains(p)\n })\n #endif\n\n return Self(_p0, _p1)\n }\n\n @inlinable public static func cover(of points: UnsafeArray) -> Self {\n\n var _p0 = points[0]\n var _p1 = points[0]\n\n for pi in 0.. _p1[i] {\n // _p1[i] = p[i] + 1\n // }\n // }\n }\n\n #if DEBUG\n let testBox = Self(_p0, _p1 + 1)\n for i in points.range {\n assert(testBox.contains(points[i]))\n }\n #endif\n\n return Self(_p0, _p1 + 1)\n }\n\n}\n"
},
{
"path": "Sources/ForceSimulation/KDTree/KDTree.swift",
"content": "\n/// A node in NDTree\n/// - Note: `NDTree` is a generic type that can be used in any dimension.\n/// `NDTree` is a value type.\npublic struct KDTree\nwhere\n Vector: SimulatableVector & L2NormCalculatable,\n Delegate: KDTreeDelegate\n{\n public typealias NodeIndex = Delegate.NodeID\n public typealias Direction = Int\n public typealias Box = KDBox\n\n public var box: Box\n public var children: [KDTree]?\n public var nodePosition: Vector?\n public var nodeIndices: [NodeIndex]\n\n @inlinable var clusterDistanceSquared: Vector.Scalar {\n return Vector.clusterDistanceSquared\n }\n\n public var delegate: Delegate\n\n @inlinable\n public init(\n box: Box,\n // clusterDistanceSquared: Vector.Scalar,\n spawnedDelegateBeingConsumed: Delegate\n ) {\n self.box = box\n self.nodeIndices = []\n self.delegate = spawnedDelegateBeingConsumed\n }\n\n @inlinable\n init(\n box: Box,\n spawnedDelegateBeingConsumed: Delegate,\n childrenBeingConsumed: [KDTree]\n ) {\n self.box = box\n self.nodeIndices = []\n self.delegate = spawnedDelegateBeingConsumed\n self.children = childrenBeingConsumed\n }\n\n @inlinable\n static var directionCount: Int { 1 << Vector.scalarCount }\n\n @inlinable\n mutating func cover(_ point: Vector) {\n if box.contains(point) { return }\n\n repeat {\n let direction = getIndexInChildren(point, relativeTo: box.p0)\n expand(towards: direction)\n } while !box.contains(point)\n }\n /// Get the index of the child that contains the point.\n ///\n /// **Complexity**: `O(n*(2^n))`, where `n` is the dimension of the vector.\n @inlinable\n func getIndexInChildren(_ point: Vector, relativeTo originalPoint: Vector) -> Int {\n var index = 0\n\n let mask = point .>= originalPoint\n\n for i in 0..]()\n result.reserveCapacity(Self.directionCount)\n // let center = newRootBox.center\n\n for j in 0..> i) & 0b1\n\n // TODO: use simd mask\n if isOnTheHigherRange != 0 {\n __box.p0[i] = _corner[i]\n } else {\n __box.p1[i] = _corner[i]\n }\n }\n result.append(\n Self(\n box: __box,\n // clusterDistanceSquared: clusterDistanceSquared,\n spawnedDelegateBeingConsumed: j != nailedDirection ? self.delegate : spawned\n )\n )\n }\n\n // result[nailedDirection] = tempSelf\n\n self = Self(\n box: newRootBox,\n spawnedDelegateBeingConsumed: self.delegate,\n childrenBeingConsumed: result\n )\n\n }\n\n @inlinable\n public mutating func add(_ nodeIndex: NodeIndex, at point: Vector) {\n cover(point)\n addWithoutCover(nodeIndex, at: point)\n }\n\n @inlinable\n public mutating func addWithoutCover(_ nodeIndex: NodeIndex, at point: Vector) {\n defer {\n delegate.didAddNode(nodeIndex, at: point)\n }\n guard children != nil else {\n if nodePosition == nil {\n nodeIndices.append(nodeIndex)\n nodePosition = point\n return\n } else if nodePosition!.distanceSquared(to: point) < clusterDistanceSquared {\n // the condition (nodePosition == point) is mostly only true when the tree is initialized\n // hence omitted\n nodeIndices.append(nodeIndex)\n return\n } else {\n\n var spawnedChildren = [KDTree]()\n spawnedChildren.reserveCapacity(Self.directionCount)\n let spawendDelegate = self.delegate.spawn()\n let center = box.center\n\n for j in 0..> i) & 0b1\n // TODO: use simd mask\n if isOnTheHigherRange != 0 {\n __box.p0[i] = center[i]\n } else {\n __box.p1[i] = center[i]\n }\n }\n spawnedChildren.append(\n Self(\n box: __box,\n // clusterDistanceSquared: clusterDistanceSquared,\n spawnedDelegateBeingConsumed: spawendDelegate\n )\n )\n }\n if let nodePosition {\n let direction = getIndexInChildren(nodePosition, relativeTo: box.center)\n spawnedChildren[direction].nodeIndices = self.nodeIndices\n spawnedChildren[direction].nodePosition = self.nodePosition\n spawnedChildren[direction].delegate = self.delegate\n self.nodeIndices = []\n self.nodePosition = nil\n // TODO: Consume\n }\n\n let directionOfNewNode = getIndexInChildren(point, relativeTo: box.center)\n spawnedChildren[directionOfNewNode].addWithoutCover(nodeIndex, at: point)\n\n self.children = spawnedChildren\n return\n\n }\n }\n\n let directionOfNewNode = getIndexInChildren(point, relativeTo: box.center)\n self.children![directionOfNewNode].addWithoutCover(nodeIndex, at: point)\n return\n }\n}\n\nextension KDTree where Delegate.NodeID == Int {\n\n /// Initialize a KDTree with a list of points and a key path to the vector.\n ///\n /// - Parameters:\n /// - points: A list of points. The points are only used to calculate the covering box. You should still call `add` to add the points to the tree.\n /// - clusterDistance: If 2 points are close enough, they will be clustered into the same leaf node.\n /// - buildRootDelegate: A closure that tells the tree how to initialize the data you want to store in the rootPointer.\n /// The closure is called only once. The `NDTreeDelegate` will then be created in children tree nods by calling `spawn` on the rootPointer delegate.\n @inlinable\n public init(\n covering points: [Vector],\n buildRootDelegate: () -> Delegate\n ) {\n let coveringBox = Box.cover(of: points)\n self.init(\n box: coveringBox, spawnedDelegateBeingConsumed: buildRootDelegate()\n )\n for i in points.indices {\n add(i, at: points[i])\n }\n }\n\n @inlinable\n public init(\n covering points: UnsafeArray,\n buildRootDelegate: () -> Delegate\n ) {\n let coveringBox = Box.cover(of: points)\n self.init(\n box: coveringBox, spawnedDelegateBeingConsumed: buildRootDelegate()\n )\n for i in 0..,\n rootDelegate: @autoclosure () -> Delegate\n ) {\n let coveringBox = Box.cover(of: points)\n self.init(\n box: coveringBox, spawnedDelegateBeingConsumed: rootDelegate()\n )\n for i in 0..(\n // covering points: [T],\n // keyPath: KeyPath,\n // buildRootDelegate: () -> Delegate\n // ) {\n // let coveringBox = Box.cover(of: points, keyPath: keyPath)\n // self.init(\n // box: coveringBox, clusterDistance: clusterDistance, buildRootDelegate: buildRootDelegate\n // )\n // for i in points.indices {\n // add(i, at: points[i][keyPath: keyPath])\n // }\n // }\n}\n\nextension KDTree {\n\n /// The bounding box of the current node\n @inlinable public var extent: Box { box }\n\n /// Returns true is the current tree node is leaf.\n ///\n /// Does not guarantee that the tree node has point in it.\n @inlinable public var isLeaf: Bool { children == nil }\n\n /// Returns true is the current tree node is internal.\n ///\n /// Internal tree node are always empty and do not contain any points.\n @inlinable public var isInternalNode: Bool { children != nil }\n\n /// Returns true is the current tree node is leaf and has point in it.\n @inlinable public var isFilledLeaf: Bool { nodePosition != nil }\n\n /// Returns true is the current tree node is leaf and does not have point in it.\n @inlinable public var isEmptyLeaf: Bool { nodePosition == nil }\n\n /// Visit the tree in pre-order.\n ///\n /// - Parameter shouldVisitChildren: a closure that returns a boolean value indicating whether should continue to visit children.\n @inlinable public mutating func visit(\n shouldVisitChildren: (inout KDTree) -> Bool\n ) {\n if shouldVisitChildren(&self) && children != nil {\n // this is an internal node\n for i in children!.indices {\n children![i].visit(shouldVisitChildren: shouldVisitChildren)\n }\n }\n }\n\n}\n"
},
{
"path": "Sources/ForceSimulation/KDTree/KDTreeDelegate.swift",
"content": "//\n// NDTree.swift\n//\n//\n// Created by li3zhen1 on 10/14/23.\n//\n\n/// The data structure carried by a node of NDTree. \n///\n/// It receives notifications when a node is added or removed on a node, \n/// regardless of whether the node is internal or leaf.\n/// It is designed to calculate properties like a box's center of mass.\n/// \n/// When implementing your delegates, ensure they\n/// are value types to enable memberwise copy.\npublic protocol KDTreeDelegate {\n associatedtype NodeID: Hashable\n associatedtype Vector: SIMD where Vector.Scalar: FloatingPoint & ExpressibleByFloatLiteral\n\n /// Called when a node is added on a node, regardless of whether the node is internal or leaf.\n ///\n /// If you add `n` points to the root, this method will be called `n` times in the root delegate,\n /// although it is probably not containing points now.\n /// - Parameters:\n /// - node: The nodeID of the node that is added.\n /// - position: The position of the node that is added.\n @inlinable mutating func didAddNode(_ node: NodeID, at position: Vector)\n\n /// Called when a node is removed on a node, regardless of whether the node is internal or leaf.\n @inlinable mutating func didRemoveNode(_ node: NodeID, at position: Vector)\n\n /// Copy object.\n ///\n /// This method is called when the root box is not large enough to cover the new nodes.\n // @inlinable func copy() -> Self\n\n /// Create new object with properties set to initial value as if the box is empty.\n ///\n /// However, you can still carry something like a closure to get information from outside.\n /// This method is called when a leaf box is splited due to the insertion of a new node in this box.\n @inlinable func spawn() -> Self\n \n}\n"
},
{
"path": "Sources/ForceSimulation/KDTree/KDTreeNode.swift",
"content": "public struct KDTreeNode\nwhere\n Vector: SimulatableVector & L2NormCalculatable,\n Delegate: KDTreeDelegate\n{\n public var box: KDBox\n public var nodePosition: Vector\n public var childrenBufferPointer: UnsafeMutablePointer?\n\n @usableFromInline\n internal var nodeIndices: NodeIndex?\n public var delegate: Delegate\n\n @inlinable\n init(\n nodeIndices: NodeIndex?,\n childrenBufferPointer: UnsafeMutablePointer?,\n delegate: Delegate,\n box: KDBox,\n nodePosition: Vector = .zero\n ) {\n self.childrenBufferPointer = childrenBufferPointer\n self.nodeIndices = nodeIndices\n self.delegate = delegate\n self.box = box\n self.nodePosition = nodePosition\n }\n\n @inlinable\n mutating public func disposeNodeIndices() {\n nodeIndices?.dispose()\n nodeIndices = nil\n }\n}\n\nextension KDTreeNode {\n\n\n @usableFromInline\n struct NodeIndex: Disposable {\n\n @usableFromInline\n var index: Int\n\n @usableFromInline\n var next: UnsafeMutablePointer?\n\n }\n}\n\nextension KDTreeNode.NodeIndex {\n\n @inlinable\n internal init(\n nodeIndex: Int\n ) {\n self.index = nodeIndex\n self.next = nil\n }\n\n @inlinable\n internal init(\n _ nodeIndex: Int\n ) {\n self.index = nodeIndex\n self.next = nil\n }\n\n\n @inlinable\n internal mutating func append(nodeIndex: Int) {\n if let next {\n next.pointee.append(nodeIndex: nodeIndex)\n } else {\n next = .allocate(capacity: 1)\n next!.initialize(to: .init(nodeIndex: nodeIndex))\n // next!.pointee = .init(nodeIndex: nodeIndex)\n }\n }\n\n @inlinable\n internal func dispose() {\n if let next {\n next.pointee.dispose()\n next.deallocate()\n }\n }\n\n @inlinable\n internal func contains(_ nodeIndex: Int) -> Bool {\n if index == nodeIndex { return true }\n if let next {\n return next.pointee.contains(nodeIndex)\n } else {\n return false\n }\n }\n\n @inlinable\n internal func forEach(_ body: (Int) -> Void) {\n body(index)\n if let next {\n next.pointee.forEach(body)\n }\n }\n}\n\nextension KDTreeNode {\n /// Returns true is the current tree node is leaf.\n ///\n /// Does not guarantee that the tree node has point in it.\n @inlinable public var isLeaf: Bool { childrenBufferPointer == nil }\n\n /// Returns true is the current tree node is internal.\n ///\n /// Internal tree node are always empty and do not contain any points.\n @inlinable public var isInternalNode: Bool { childrenBufferPointer != nil }\n\n /// Returns true is the current tree node is leaf and has point in it.\n @inlinable public var isFilledLeaf: Bool { nodeIndices != nil }\n\n /// Returns true is the current tree node is leaf and does not have point in it.\n @inlinable public var isEmptyLeaf: Bool { nodeIndices == nil }\n\n /// Visit the tree in pre-order.\n ///\n /// - Parameter shouldVisitChildren: a closure that returns a boolean value indicating whether should continue to visit children.\n @inlinable public mutating func visit(\n shouldVisitChildren: (inout KDTreeNode) -> Bool\n ) {\n if shouldVisitChildren(&self) && childrenBufferPointer != nil {\n // this is an internal node\n for i in 0...directionCount {\n childrenBufferPointer![i].visit(shouldVisitChildren: shouldVisitChildren)\n }\n }\n }\n\n /// Returns an array of point indices in the tree node.\n @inlinable\n public var containedIndices: [Int] {\n guard isFilledLeaf else { return [] }\n var result: [Int] = []\n nodeIndices!.forEach { result.append($0) }\n return result\n }\n\n @inlinable\n static func zeroWithDelegate(_ delegate: Delegate) -> Self {\n return Self(\n nodeIndices: nil,\n childrenBufferPointer: nil,\n delegate: delegate,\n box: .zero,\n nodePosition: .zero\n )\n }\n\n}\n"
},
{
"path": "Sources/ForceSimulation/Kinetics.swift",
"content": "/// A class that holds the state of the simulation, which\n/// includes the positions, velocities of the nodes.\npublic struct Kinetics\nwhere Vector: SimulatableVector & L2NormCalculatable {\n\n /// The position of points stored in simulation.\n ///\n /// Ordered as the nodeIds you passed in when initializing simulation.\n /// They are always updated.\n /// Exposed publicly so examples & clients can read out the latest positions.\n public var position: UnsafeArray\n\n // public var positionBufferPointer: UnsafeMutablePointer\n\n /// The velocities of points stored in simulation.\n ///\n /// Ordered as the nodeIds you passed in when initializing simulation.\n /// They are always updated.\n @usableFromInline\n package var velocity: UnsafeArray\n\n // public var velocityBufferPointer: UnsafeMutablePointer\n\n /// The fixed positions of points stored in simulation.\n ///\n /// Ordered as the nodeIds you passed in when initializing simulation.\n /// They are always updated.\n @usableFromInline\n package var fixation: UnsafeArray\n\n\n public var validCount: Int\n public var alpha: Vector.Scalar\n public let alphaMin: Vector.Scalar\n public let alphaDecay: Vector.Scalar\n public let alphaTarget: Vector.Scalar\n public let velocityDecay: Vector.Scalar\n\n @usableFromInline\n var randomGenerator: Vector.Scalar.Generator\n\n\n\n @usableFromInline\n package let links: [EdgeID]\n\n // public var validRanges: [Range]\n // public var validRanges: Range\n\n @inlinable\n package var range: Range {\n return 0..],\n initialAlpha: Vector.Scalar,\n alphaMin: Vector.Scalar,\n alphaDecay: Vector.Scalar,\n alphaTarget: Vector.Scalar,\n velocityDecay: Vector.Scalar,\n position: [Vector],\n velocity: [Vector],\n fixation: [Vector?]\n ) {\n self.links = links\n // self.initializedAlpha = initialAlpha\n self.alpha = initialAlpha\n self.alphaMin = alphaMin\n self.alphaDecay = alphaDecay\n self.alphaTarget = alphaTarget\n self.velocityDecay = velocityDecay\n\n let count = position.count\n self.validCount = count\n\n self.position = .createBuffer(moving: position, fillingWithIfFailed: .zero)\n self.velocity = .createBuffer(moving: velocity, fillingWithIfFailed: .zero)\n self.fixation = .createBuffer(moving: fixation, fillingWithIfFailed: nil)\n self.randomGenerator = .init()\n }\n\n @inlinable\n package static var empty: Kinetics {\n Kinetics(\n links: [],\n initialAlpha: 0,\n alphaMin: 0,\n alphaDecay: 0,\n alphaTarget: 0,\n velocityDecay: 0,\n position: [],\n velocity: [],\n fixation: []\n )\n }\n\n}\n\nextension Kinetics {\n @inlinable\n @inline(__always)\n func updatePositions() {\n for i in range {\n if let fix = fixation[i] {\n position[i] = fix\n } else {\n velocity[i] *= velocityDecay\n position[i] += velocity[i]\n }\n }\n }\n\n @inlinable\n @inline(__always)\n mutating func updateAlpha() {\n alpha += alphaTarget - alpha * alphaDecay\n }\n\n}\n\npublic typealias Kinetics2D = Kinetics>\npublic typealias Kinetics3D = Kinetics>\n"
},
{
"path": "Sources/ForceSimulation/Simulation.swift",
"content": "@usableFromInline\npackage enum Ticks: Sendable {\n case untilReachingAlpha(Scalar?)\n case iteration(Int)\n\n @inlinable\n public static var zero: Self {\n .iteration(0)\n }\n\n @inlinable\n public static var untilStable: Self {\n .untilReachingAlpha(nil)\n }\n}\n\n/// An any-dimensional force simulation.\n/// The points are placed in a space where you use a SIMD data structure\n/// to describe their coordinates.\npublic final class Simulation: @unchecked Sendable\nwhere Vector: SimulatableVector & L2NormCalculatable, ForceField: ForceProtocol {\n\n @usableFromInline\n var forceField: ForceField\n\n public var kinetics: Kinetics\n\n /// Create a new simulation.\n ///\n /// - Parameters:\n /// - nodeCount: Count of the nodes. Force simulation calculate them by order once created.\n /// - links: The links between nodes.\n /// - forceField: The force field that drives the simulation. The simulation takes ownership of the force field.\n /// - alpha: Initial alpha value, determines how \"active\" the simulation is.\n /// - alphaMin: The minimum alpha value. The simulation stops when alpha is less than this value.\n /// - alphaDecay: The larger the value, the faster the simulation converges to the final result.\n /// - alphaTarget: The alpha value the simulation converges to.\n /// - velocityDecay: A multiplier for the velocity of the nodes in Velocity Verlet integration. The position of the nodes is updated by the formula `x += v * velocityDecay`.\n // @inlinable\n // public init(\n // nodeCount: Int,\n // links: [EdgeID],\n // forceField: ForceField,\n // initialAlpha: Vector.Scalar = 1,\n // alphaMin: Vector.Scalar = 1e-2,\n // alphaDecay: Vector.Scalar = 2e-3,\n // alphaTarget: Vector.Scalar = 0.0,\n // velocityDecay: Vector.Scalar = 0.6\n // ) {\n // self.kinetics = .createZeros(\n // links: links,\n // initialAlpha: initialAlpha,\n // alphaMin: alphaMin,\n // alphaDecay: alphaDecay,\n // alphaTarget: alphaTarget,\n // velocityDecay: velocityDecay,\n // count: nodeCount\n // )\n // // self.kinetics.jigglePosition()\n // forceField.bindKinetics(self.kinetics)\n // self.forceField = forceField\n // }\n\n /// Create a new simulation.\n ///\n /// - Parameters:\n /// - nodeCount: Count of the nodes. Force simulation calculate them by order once created.\n /// - links: The links between nodes.\n /// - forceField: The force field that drives the simulation. The simulation takes ownership of the force field.\n /// - alpha: Initial alpha value, determines how \"active\" the simulation is.\n /// - alphaMin: The minimum alpha value. The simulation stops when alpha is less than this value.\n /// - alphaDecay: The larger the value, the faster the simulation converges to the final result.\n /// - alphaTarget: The alpha value the simulation converges to.\n /// - velocityDecay: A multiplier for the velocity of the nodes in Velocity Verlet integration. The position of the nodes is updated by the formula `x += v * velocityDecay`.\n @inlinable\n public init(\n nodeCount: Int,\n links: [EdgeID],\n forceField: consuming ForceField,\n initialAlpha: Vector.Scalar = 1,\n alphaMin: Vector.Scalar = 1e-3,\n alphaDecay: Vector.Scalar = 1e-2,\n alphaTarget: Vector.Scalar = 0.0,\n velocityDecay: Vector.Scalar = 0.6,\n position: [Vector]? = nil,\n velocity: [Vector]? = nil,\n fixation: [Vector?]? = nil\n ) {\n\n self.kinetics = Kinetics(\n links: links,\n initialAlpha: initialAlpha,\n alphaMin: alphaMin,\n alphaDecay: alphaDecay,\n alphaTarget: alphaTarget,\n velocityDecay: velocityDecay,\n position: position ?? Array(repeating: .zero, count: nodeCount),\n velocity: velocity ?? Array(repeating: .zero, count: nodeCount),\n fixation: fixation ?? Array(repeating: nil, count: nodeCount)\n )\n // self.kinetics.jigglePosition()\n forceField.bindKinetics(self.kinetics)\n self.forceField = forceField\n }\n\n /// Run a number of iterations of ticks.\n @inlinable\n @inline(__always)\n public func tick(iterations: UInt = 1) {\n // print(self.kinetics.alpha, self.kinetics.alphaMin)\n guard self.kinetics.alpha >= self.kinetics.alphaMin else { return }\n for _ in 0..) {\n switch ticks {\n case .iteration(let count):\n self.tick(iterations: UInt(count))\n case .untilReachingAlpha(let alpha):\n let alpha = alpha ?? self.kinetics.alphaMin\n while self.kinetics.alpha >= alpha {\n self.kinetics.updateAlpha()\n self.forceField.apply(to: &self.kinetics)\n self.kinetics.updatePositions()\n }\n }\n }\n\n @inlinable\n deinit {\n self.forceField.dispose()\n }\n\n}\n\npublic typealias Simulation2D = Simulation, ForceField>\nwhere ForceField: ForceProtocol>\n\npublic typealias Simulation3D = Simulation, ForceField>\nwhere ForceField: ForceProtocol>\n"
},
{
"path": "Sources/ForceSimulation/Utils/AttributeDescriptor.swift",
"content": "public enum AttributeDescriptor {\n case varied((Int) -> T)\n case constant(T)\n}\n\nextension AttributeDescriptor: Equatable where T: Equatable {\n \n @inlinable\n public static func == (lhs: AttributeDescriptor, rhs: AttributeDescriptor) -> Bool {\n switch (lhs, rhs) {\n case (.constant(let l), .constant(let r)):\n return l == r\n default:\n return false\n }\n }\n}\n\nextension AttributeDescriptor {\n @inlinable\n func calculate(for count: Int) -> [T] {\n switch self {\n case .constant(let m):\n return [T](repeating: m, count: count)\n case .varied(let radiusProvider):\n return (0.. UnsafeArray where T: Numeric {\n switch self {\n case .constant(let m):\n return UnsafeArray
![\"grape-icon\"](\"https://github.com/swiftgraphs/Grape/assets/45376537/4ab08ea1-22e6-4fe8-ab2b-99ae325b46a6\")
\n ![\"swift](\"https://img.shields.io/endpoint?color=FA7343&url=https://swiftpackageindex.com/api/packages/swiftgraphs/Grape/badge?type=platforms\")
![\"swift](\"https://img.shields.io/endpoint?color=FA7343&url=https://swiftpackageindex.com/api/packages/swiftgraphs/Grape/badge?type=swift-versions\")
![\"A](\"https://raw.githubusercontent.com/swiftgraphs/Grape/main/Assets/SimulationDiagram.svg\")
\n