├── .gitignore ├── Challenge-Solution.ipynb ├── Challenge.ipynb ├── DevelopGuide.md ├── LICENSE ├── README.md ├── REQUIRE ├── ToolChain.md ├── data ├── barcode.png └── goblin.png ├── environment.yml ├── programs ├── example.txt ├── fsa.f90 ├── problem.f90 ├── sa.py └── testsa.py ├── simulated_annealing-Solution.ipynb └── simulated_annealing.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | *.jl.cov 2 | *.jl.*.cov 3 | *.jl.mem 4 | *.mod 5 | *.so 6 | 7 | docs/build/ 8 | docs/site/ 9 | 10 | *.ipynb_checkpoints 11 | **/*.ipynb_checkpoints 12 | **/**/*.ipynb_checkpoints 13 | 14 | _*.dat 15 | _*.jld2 16 | *.swp 17 | __pycache__/ 18 | 19 | Manifest.toml 20 | _local/ 21 | -------------------------------------------------------------------------------- /Challenge.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Section 0: Introduction" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## What is Julia\n", 15 | "* [Julia](https://julialang.org/) is an open-source, multi-platform, high-level, high-performance programming language for technical computing.\n", 16 | "* Julia has an [LLVM](https://en.wikipedia.org/wiki/LLVM)-based [JIT](https://en.wikipedia.org/wiki/Just-in-time_compilation) compiler that allows it to match the performance of languages such as C and [FORTRAN](https://en.wikipedia.org/wiki/FORTRAN) without the hassle of low-level code. Because the code is compiled on the fly you can run (bits of) code in a shell or [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop), which is part of the recommended workflow.\n", 17 | "* Julia is dynamically typed, provides [multiple dispatch](https://en.wikipedia.org/wiki/Multiple_dispatch), and is designed for parallelism and distributed computation.\n", 18 | "* Julia has a built-in package manager [Pkg3](https://docs.julialang.org/en/v1/stdlib/Pkg/index.html).\n", 19 | "* Julia has many built-in mathematical functions, including special functions (e.g. Gamma), and supports complex numbers right out of the box.\n", 20 | "* Julia allows you to generate code automagically thanks to [Lisp](https://en.wikipedia.org/wiki/Lisp_(programming_language))-inspired macros.\n", 21 | "* Julia was born in 2012." 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "## Learn Julia\n", 29 | "#### Book\n", 30 | "[Think Julia](https://benlauwens.github.io/ThinkJulia.jl/latest/book.html), Allen Downey and Ben Lauwens\n", 31 | "\n", 32 | "[Hands-On Design Patterns and Best Practices with Julia: Proven solutions to common problems in software design for Julia 1.x](https://www.amazon.com/Hands-Design-Patterns-Julia-comprehensive-ebook/dp/B07SHV9PVV), Tom Kwong\n", 33 | "#### Cousera online Course\n", 34 | "[Julia Scientific Programming](https://www.coursera.org/learn/julia-programming)\n", 35 | "#### Other Coding Tutorial\n", 36 | "[TutorialForPhysicists - Roger](https://github.com/Roger-luo/TutorialForPhysicists.jl)" 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "## Julia ABC\n", 44 | "* To enter julia REPL, type `julia` in your terminal (PATH variable in shell should be set correctly).\n", 45 | "* To get help, type `?` in a Julia REPL to enter `API` mode.\n", 46 | "* To install a julia package, type `]` in a Julia REPL to enter `Pkg` mode. Type `?[Enter]` if you want some help in `Pkg` mode.\n", 47 | "* To run shell command, type `;` in a julia REPL to enter shell mode.\n", 48 | "* To input `≈`, type `\\approx[TAB]`, other unicodes can be typed similarly, check [here](https://docs.julialang.org/en/v1/manual/unicode-input/).\n", 49 | "* Special \"function\" names that start with `@` is called a [macro](https://docs.julialang.org/en/v1/manual/metaprogramming/). It runs in compile time, and changes the expression directly. For example, `@test` is a macro that throws an exception whenever the statement following which returns `false`.\n", 50 | "\n", 51 | "\n", 52 | "## [Cheat Sheet](https://juliadocs.github.io/Julia-Cheat-Sheet/) [$\\leftarrow$ CLICK] is available!\n", 53 | "### **What's Special?**" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": null, 59 | "metadata": {}, 60 | "outputs": [], 61 | "source": [ 62 | "# how to import a package\n", 63 | "using Test\n", 64 | "using LinearAlgebra: I\n", 65 | "\n", 66 | "# matrix, type `\\sigma[TAB]\\^y[TAB]` to input σʸ\n", 67 | "σʸ = [0 -im; im 0]\n", 68 | "# transpose\n", 69 | "@test (im*σʸ)' == -(im*σʸ)\n", 70 | "# broadcast/vectorize (every function can vectorize)\n", 71 | "@test σʸ.^2 == [0 -1; -1 0]\n", 72 | "\n", 73 | "# how to print\n", 74 | "println(\"hello $σʸ !\")\n", 75 | "@show σʸ[1:end,:] # index as an array, start from 1!\n", 76 | "@show σʸ[1:end] # index as a vector\n", 77 | "\n", 78 | "# void\n", 79 | "@test NaN != nothing\n", 80 | "\n", 81 | "# List like vector\n", 82 | "arr = Float64[]\n", 83 | "push!(arr, 3)\n", 84 | "brr = Any[1,2]\n", 85 | "brr[1] = \"Some text\";" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "# Section I: Take your weapon and arm yourselves\n", 93 | "In this section, we will learn the toolchain for physicists" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "## Basic Array Operations" 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": null, 106 | "metadata": {}, 107 | "outputs": [], 108 | "source": [ 109 | "# Julia Matrix Operation is fast. To know how fast it is, you need a benchmark package. Type `]` and `add BenchmarkTools` in your REPL.\n", 110 | "using BenchmarkTools, Test\n", 111 | "\n", 112 | "cnot = [1 0 0 0; 0 1 0 0; 0 0 0 1; 0 0 1 0] # a matrix\n", 113 | "b = [1, 1im, true, 0.4e2] # a vector\n", 114 | "c = [1, 1im, 0.4e2, true] # a vector\n", 115 | "\n", 116 | "# run tests\n", 117 | "@test cnot*b ≈ c\n", 118 | "@test_throws DimensionMismatch cnot*randn(3) # expected to raise specific error\n", 119 | "\n", 120 | "# run a benchmark\n", 121 | "res1 = @benchmark $cnot*$b # `$` sign means evaluation first, used in `@benchmark` to avoid taking time to evaluate cnot input account." 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "## Faster Array Operations for Small Matrices\n", 129 | "\n", 130 | "Static arrays do not have allocations, it is widely used in the quantum circuit simulator [Yao.jl](https://github.com/QuantumBFS/Yao.jl).\n", 131 | "\n", 132 | "### **Challenge!**\n", 133 | "Read the documentation of package `StaticArrays`\n", 134 | "https://github.com/JuliaArrays/StaticArrays.jl\n", 135 | "and show it is really fast!" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [ 144 | "# install `StaticArrays`\n", 145 | "\n", 146 | "using StaticArrays: SMatrix, SVector\n", 147 | "# scnot = \n", 148 | "# sb = \n", 149 | "\n", 150 | "@testset \"static arrays\" begin\n", 151 | " @test scnot*sb ≈ c\n", 152 | " using Statistics: median\n", 153 | " res2 = @benchmark $scnot*$sb\n", 154 | " println(\"median of time is $(median(res2).time)\")\n", 155 | " @test median(res2).time < median(res1).time / 5 # at least 5 times faster\n", 156 | "end" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "## Linear Algebra\n", 164 | "\n", 165 | "Linear algebra functions are described in [docs](https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/).\n", 166 | "They are widely used in quantum Monte Carlo, Machine learning et al.\n", 167 | "\n", 168 | "### **Challenge!**\n", 169 | "Try to figure out how to use get eigenvalues, singular values, QR-decomposition, determinant and trace for `cnot` matrix and pass the test" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": {}, 176 | "outputs": [], 177 | "source": [ 178 | "using LinearAlgebra: eigen, svd, qr, I, det, tr\n", 179 | "# hint, here you probabily want to type `?` and `eigen` to get help in an REPL.\n", 180 | "\n", 181 | "# sv_cnot = \n", 182 | "# ev_cnot = \n", 183 | "# q_cnot = \n", 184 | "# det_cnot = \n", 185 | "# tr_cnot = \n", 186 | "\n", 187 | "@testset \"linalg\" begin\n", 188 | " @test sv_cnot ≈ ones(4)\n", 189 | " @test ev_cnot ≈ [-1, 1, 1, 1]\n", 190 | " @test q_cnot*q_cnot' ≈ I\n", 191 | " @test det_cnot == -1\n", 192 | " @test tr_cnot == 2\n", 193 | "end" 194 | ] 195 | }, 196 | { 197 | "cell_type": "markdown", 198 | "metadata": {}, 199 | "source": [ 200 | "## Large sparse matrix eigensolver\n", 201 | "\n", 202 | "[KrylovKit](https://github.com/Jutho/KrylovKit.jl) is a package for solving large sparse matrix.\n", 203 | "\n", 204 | "\n", 205 | "### **Used in**\n", 206 | "* Exact diagonalization\n", 207 | "* Cluster pertubation theory (CPT)\n", 208 | "* Numerical Renomalization Group\n", 209 | "\n", 210 | "### **Challenge!**\n", 211 | "Get the lowest singular value of specific sparse matrix" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [ 220 | "using SparseArrays: SparseMatrixCSC, sparse, nnz\n", 221 | "sp = kron(SparseMatrixCSC(cnot), sparse(I, 100, 100))\n", 222 | "\n", 223 | "# install `KrylovKit`\n", 224 | "using KrylovKit: eigsolve\n", 225 | "# vals = \n", 226 | "\n", 227 | "@testset \"sparse\" begin\n", 228 | " @test sp |> nnz == 100*4 # here `x |> f` is same as calling f(x).\n", 229 | " @test vals[1] ≈ minimum(eigen(sp |> Matrix).values)\n", 230 | "end" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "## Tensor contraction\n", 238 | "\n", 239 | "[OMEinsum](https://github.com/under-Peter/OMEinsum.jl), [TensorOperations](https://github.com/Jutho/TensorOperations.jl) and [ITensors](https://github.com/ITensor/ITensors.jl) are high performance packages for tensor contractions.\n", 240 | "These packages are used in machine learning and tensor network simulations. `OMEinsum` features hyper-optimized contraction order finding, `TensorOperations` features low overhead tensor contraction, while `ITensors` is domain specific package targeting physical applications such as TRG, DMRG.\n", 241 | "\n", 242 | "\n", 243 | "### **Challenge!**\n", 244 | "Try to calculate the following contraction\n", 245 | "$C_{lj} = A_{i,j,k}B_{i,k,l}$" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": null, 251 | "metadata": {}, 252 | "outputs": [], 253 | "source": [ 254 | "A = randn(6, 10, 5)\n", 255 | "B = randn(6, 5, 7)\n", 256 | "\n", 257 | "# install OMEinsum\n", 258 | "using OMEinsum\n", 259 | "# C = \n", 260 | "\n", 261 | "@test C |> size == (7, 10)" 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "metadata": {}, 267 | "source": [ 268 | "## Save and load data\n", 269 | "\n", 270 | "[DelimitedFiles](https://docs.julialang.org/en/v1/stdlib/DelimitedFiles/index.html) is the `txt` format save and load standard module.\n", 271 | "\n", 272 | "[JLD2 and FileIO](https://github.com/simonster/JLD2.jl) uses HDF5 format to save and load, suited for large data file.\n", 273 | "\n", 274 | "\n", 275 | "### **Challenge!**\n", 276 | "Read out the saved data." 277 | ] 278 | }, 279 | { 280 | "cell_type": "code", 281 | "execution_count": null, 282 | "metadata": {}, 283 | "outputs": [], 284 | "source": [ 285 | "using DelimitedFiles\n", 286 | "\n", 287 | "a = randn(Float64, 3,3)\n", 288 | "writedlm(\"data/_test.dat\", a)\n", 289 | "# b = \n", 290 | "\n", 291 | "# FileIO\n", 292 | "# install FileIO and JLD2\n", 293 | "using FileIO, JLD2\n", 294 | "jldopen(\"data/_example.jld2\", \"w\") do f\n", 295 | " f[\"A\"] = a\n", 296 | "end\n", 297 | "\n", 298 | "# b_jld2 = \n", 299 | "@testset \"file reading\" begin\n", 300 | " @test b ≈ a\n", 301 | " @test b_jld2 ≈ a\n", 302 | "end" 303 | ] 304 | }, 305 | { 306 | "cell_type": "markdown", 307 | "metadata": {}, 308 | "source": [ 309 | "# Section II: Road to master" 310 | ] 311 | }, 312 | { 313 | "cell_type": "markdown", 314 | "metadata": {}, 315 | "source": [ 316 | "## Correctly Dispatch Functions\n", 317 | "\n", 318 | "[Function]((https://docs.julialang.org/en/v1/manual/functions/)) can be dispatched by types, so it heavily relied on [type trees](https://docs.julialang.org/en/v1/manual/types/).\n", 319 | "[Macro](https://docs.julialang.org/en/v1/manual/metaprogramming/#Macros-and-dispatch-1) is similar to function, but is a kind of code generation!" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": null, 325 | "metadata": {}, 326 | "outputs": [], 327 | "source": [ 328 | "\"\"\"This is a utility of showing subtype tree.\"\"\"\n", 329 | "function subtypetree(t, level=1, indent=4)\n", 330 | " level == 1 && println(t)\n", 331 | " for s in subtypes(t)\n", 332 | " println(join(fill(\" \", level * indent)) * string(s))\n", 333 | " subtypetree(s, level+1, indent)\n", 334 | " end\n", 335 | "end" 336 | ] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": null, 341 | "metadata": {}, 342 | "outputs": [], 343 | "source": [ 344 | "subtypetree(Number)" 345 | ] 346 | }, 347 | { 348 | "cell_type": "code", 349 | "execution_count": null, 350 | "metadata": {}, 351 | "outputs": [], 352 | "source": [ 353 | "dump(Array)" 354 | ] 355 | }, 356 | { 357 | "cell_type": "markdown", 358 | "metadata": {}, 359 | "source": [ 360 | "### **Challenge!**\n", 361 | "Fix following tests." 362 | ] 363 | }, 364 | { 365 | "cell_type": "code", 366 | "execution_count": null, 367 | "metadata": { 368 | "scrolled": true 369 | }, 370 | "outputs": [], 371 | "source": [ 372 | "@testset \"types\" begin\n", 373 | " @test 1.0 isa Float64\n", 374 | " @test 1.0 isa Real\n", 375 | " @test typeof(1.0) == Float64\n", 376 | " \n", 377 | " # type relation\n", 378 | " @test Int64 <: Int\n", 379 | " @test Int64 === Int\n", 380 | " @test Int64 <: Integer\n", 381 | " @test Int64 <: Union{Int64, Complex}\n", 382 | " @test Array{ComplexF64, 3} <: Array{ComplexF64}\n", 383 | " @test Array{ComplexF64, 3} <: Array{Complex, 3}\n", 384 | " @test supertype(Integer) == Real\n", 385 | " @test Signed in subtypes(Integer)\n", 386 | " \n", 387 | " # type promotion\n", 388 | " @test eltype(promote(1.0, 2im)) == Complex\n", 389 | " @test promote_type(Float32, Float64) == Float64\n", 390 | " @test promote_type(Int64, Real, Float64) == Float64\n", 391 | " \n", 392 | " # element types\n", 393 | " @test eltype([1, 2, 3.0]) == Vector{Float64}\n", 394 | " @test eltype(Int[1, 2, 3.0]) == Int64\n", 395 | " \n", 396 | "end" 397 | ] 398 | }, 399 | { 400 | "cell_type": "code", 401 | "execution_count": null, 402 | "metadata": {}, 403 | "outputs": [], 404 | "source": [ 405 | "#=\n", 406 | " define function f here\n", 407 | "=#\n", 408 | "@testset \"functions\" begin\n", 409 | " # function and broadcast\n", 410 | " @test f(3) == 9\n", 411 | " @test f.([1,2,3,4,5]) == [1,4,9,16,25] # broadcast\n", 412 | " \n", 413 | " # macro\n", 414 | " @test (@f 3) == 9\n", 415 | " #=\n", 416 | " var = 3\n", 417 | " @test (@f var) == 9 # try to uncomment this line!\n", 418 | " =#\n", 419 | " \n", 420 | " @test f(\"bili\") == \"bilibili\"\n", 421 | " @test f.([\"bili\", \"dili\"]) == [\"bilibili\", \"dilidili\"]\n", 422 | "\n", 423 | " x = [1, 2, 3]\n", 424 | " y = [1im, 2+3im, 3]\n", 425 | " @test f(x) == [1,2,3,1,2,3] # repeat the array\n", 426 | " @test f(y) == [1im,2+3im,3,-1im,2-3im,3] # repeat, but with conjugate\n", 427 | " y = copy(x)\n", 428 | " @test (f!(y); y) == [1,2,3,1,2,3] # inplace version of f\n", 429 | "end" 430 | ] 431 | }, 432 | { 433 | "cell_type": "markdown", 434 | "metadata": {}, 435 | "source": [ 436 | "### **Challenge!**\n", 437 | "Metaprogramming can be used to generate functions! Try to generate functions after reading [this section](https://docs.julialang.org/en/v1/manual/metaprogramming/#Generated-functions-1).\n", 438 | "\n", 439 | "Metaprogramming is a **black technology** in Julia, especially important in multiple dispatch framework. It will save you time if used properly, but can also cause trouble in code readability (where is this function defined?)." 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": null, 445 | "metadata": {}, 446 | "outputs": [], 447 | "source": [ 448 | "FUNCS = Symbol.('a' .+ (0:4))\n", 449 | "#=\n", 450 | " define your functions here.\n", 451 | "=#\n", 452 | "\n", 453 | "@testset \"generated functions\" begin\n", 454 | " @test a_gen(3) == 9\n", 455 | " @test b_gen(3) == 9\n", 456 | " @test c_gen(3) == 9\n", 457 | " @test d_gen(3) == 9\n", 458 | " @test e_gen(3) == 9\n", 459 | "end" 460 | ] 461 | }, 462 | { 463 | "cell_type": "markdown", 464 | "metadata": {}, 465 | "source": [ 466 | "## Type Stability\n", 467 | "\n", 468 | "[Type stability](https://docs.julialang.org/en/v1/manual/performance-tips/index.html#Avoid-changing-the-type-of-a-variable-1) is very important knowledge for writing high performance Julia programs.\n", 469 | "\n", 470 | "### **Challenge!**\n", 471 | "Fix the allocation below to increase the performance of calculating Fibonacci." 472 | ] 473 | }, 474 | { 475 | "cell_type": "code", 476 | "execution_count": null, 477 | "metadata": {}, 478 | "outputs": [], 479 | "source": [ 480 | "# fix Fibonacci to improve performance\n", 481 | "function fib(n)\n", 482 | " a = 0\n", 483 | " b = 0b1\n", 484 | " for i = 1:n-1\n", 485 | " c = a + b\n", 486 | " a = b\n", 487 | " b = c\n", 488 | " end\n", 489 | " b\n", 490 | "end\n", 491 | "display(@benchmark fib(30))\n", 492 | "\n", 493 | "# @code_warntype will tell you a lot of type information,\n", 494 | "# if a type is not stable, it will be marked as red, with a lot of allocations.\n", 495 | "display(@code_warntype fib(30))" 496 | ] 497 | }, 498 | { 499 | "cell_type": "code", 500 | "execution_count": null, 501 | "metadata": {}, 502 | "outputs": [], 503 | "source": [ 504 | "@testset \"fibonacci\" begin\n", 505 | " @test fib(30) == 832040\n", 506 | " @test (@allocated fib(30)) == 0\n", 507 | "end" 508 | ] 509 | }, 510 | { 511 | "attachments": { 512 | "goblin.png": { 513 | "image/png": "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" 514 | } 515 | }, 516 | "cell_type": "markdown", 517 | "metadata": {}, 518 | "source": [ 519 | "# Final: Get over it and become a warrior!\n", 520 | "![goblin.png](attachment:goblin.png)\n", 521 | "Give data file `data/example.txt`, with each row a tuple of $i, j, w_{ij}$.\n", 522 | "The problems is to find the ground state configuration of the classical Ising hamiltonian $H = \\sum\\limits_{i,j} w_{ij}\\sigma_i \\sigma_j$\n", 523 | "\n", 524 | "This is the code chanlledge of 2016 UCAS summer school." 525 | ] 526 | }, 527 | { 528 | "cell_type": "code", 529 | "execution_count": null, 530 | "metadata": {}, 531 | "outputs": [], 532 | "source": [ 533 | "readdlm(\"programs/example.txt\")" 534 | ] 535 | }, 536 | { 537 | "cell_type": "markdown", 538 | "metadata": {}, 539 | "source": [ 540 | "### **Challenge!**\n", 541 | "Fix the code of simulated annealing\n", 542 | "\n", 543 | "1. correctify the code\n", 544 | "2. improve the performance" 545 | ] 546 | }, 547 | { 548 | "cell_type": "code", 549 | "execution_count": null, 550 | "metadata": {}, 551 | "outputs": [], 552 | "source": [ 553 | "# please open `simulated_annealing.ipynb` to continue" 554 | ] 555 | }, 556 | { 557 | "cell_type": "code", 558 | "execution_count": null, 559 | "metadata": {}, 560 | "outputs": [], 561 | "source": [] 562 | } 563 | ], 564 | "metadata": { 565 | "kernelspec": { 566 | "display_name": "Julia 1.8.1", 567 | "language": "julia", 568 | "name": "julia-1.8" 569 | }, 570 | "language_info": { 571 | "file_extension": ".jl", 572 | "mimetype": "application/julia", 573 | "name": "julia", 574 | "version": "1.8.1" 575 | } 576 | }, 577 | "nbformat": 4, 578 | "nbformat_minor": 2 579 | } 580 | -------------------------------------------------------------------------------- /DevelopGuide.md: -------------------------------------------------------------------------------- 1 | # Package development 2 | ## How to CODE 3 | In general, we prefer using [Juno](http://docs.junolab.org/latest/man/installation.html). 4 | Jupyter notebooks with [IJulia](https://github.com/JuliaLang/IJulia.jl) kernel is suited for writting simple code, but it is well known as hard to be version controlled. 5 | 6 | Coding in `vim` directly is not recommended since running code line by line is nessesary for debuging Julia programs (There is no `jdb`!). 7 | 8 | ## How to develop a Project 9 | ### Start a new project 10 | https://docs.julialang.org/en/v1/stdlib/Pkg/index.html#Creating-your-own-projects-1 11 | 12 | ##### comments 13 | * `activate .` sould be used when you are going to change the dependancy of a project in current folder (i.e. changing `./Project.toml`). 14 | * `uuid` contains the information of both package name and version number. 15 | 16 | ### setup continuous integration 17 | To run a test, type `julia test/runtests.jl`. 18 | To setup continuous integration for your tests and documents, you need 19 | 1. [get started](https://docs.travis-ci.com/user/getting-started/) with Travis-ci, 20 | 2. [configure `.travis.yml`](https://docs.travis-ci.com/user/customizing-the-build/) 21 | 3. [setup julia build](https://docs.travis-ci.com/user/languages/julia/), 22 | 4. [add building status badge](https://docs.travis-ci.com/user/status-images/) 23 | 5. setup [CodeCov](https://codecov.io/) to ensure test coverage, 24 | 7. use [Documenter](https://github.com/JuliaDocs/Documenter.jl/blob/master/docs/src/man/hosting.md) to deploy documents. 25 | 8. it is interesting to see how other projects (e.g. [FunnyTN](https://github.com/QuantumBFS/FunnyTN.jl)) works. 26 | 27 | ### Register your package 28 | See [METADATA](https://github.com/JuliaLang/METADATA.jl) for detail. 29 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 QuantumBFS 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Julia Challenge 2 | 3 | Can you solve all the puzzles in noteboook `Challenge.ipynb`? 4 | 5 | ## Contents 6 | [Test driven development](https://en.wikipedia.org/wiki/Test-driven_development) is not only interesting, but also good for learning a new language. 7 | Notebook `Challenge.ipynb` contains a lot of tasks specified by tests. 8 | These tests cover 9 | 10 | * Toolchain for numerical simulations (also, see the list of toolchain for physicists [here](ToolChain.md)) 11 | * Write Julia functions 12 | * Write simulated annealing 13 | 14 | Another important aspect that Julia is different from other language is package development. 15 | This part will be covered [here](DevelopGuide.md) 16 | 17 | ## Get Started 18 | 1. install julia 1.0 from [here](https://julialang.org/downloads/) and install IJulia from [here](https://github.com/JuliaLang/IJulia.jl), 19 | 2. clone this repo to your local host 20 | ```bash 21 | $ git clone https://github.com/QuantumBFS/JuliaChallenge.git 22 | $ cd JuliaChallenge 23 | ``` 24 | 3. open the notebook and **pass all the tests**! 25 | ```bash 26 | $ jupyter notebook Challenge.ipynb 27 | ``` 28 | 29 | ## Author 30 | [JinGuo Liu](https://giggleliu.github.io/) 31 | -------------------------------------------------------------------------------- /REQUIRE: -------------------------------------------------------------------------------- 1 | BenchmarkTools 2 | -------------------------------------------------------------------------------- /ToolChain.md: -------------------------------------------------------------------------------- 1 | # Tool Chain for Physicists 2 | This page is adapted from [TutorialForPhysicists](https://github.com/Roger-luo/TutorialForPhysicists.jl). 3 | Please help us benchmark these packages [:thumbsup: or :thumbsdown:?] under issue [#1](https://github.com/QuantumBFS/JuliaChallenge/issues/1)) 4 | 5 | There are some useful tools (Packages) that will help you work with Julia in Physics, but you might want to find what you want first in**Julia.jl**. 6 | 7 | - [Julia.jl](https://github.com/svaksha/Julia.jl) Curated decibans of Julia language. 8 | Standard library in Julia is consist of `LinearAlgebra`, `SparseArrays`, `Statistics` and many other useful modules. 9 | 10 | ### Tensor Operations and Linear Algebra 11 | #### Tensor Basics 12 | - :thumbsup:[OMEinsum](https://github.com/under-Peter/OMEinsum.jl) A Julia package for einsum and its contraction order optimization. 13 | - :thumbsup:[TensorOperations](https://github.com/Jutho/TensorOperations.jl) A Julia package for tensor contractions and related operations 14 | - :thumbsdown:[Einsum.jl](https://github.com/ahwillia/Einsum.jl) Einstein summation notation in Julia 15 | - [CuArrays.jl](https://github.com/JuliaGPU/CuArrays.jl) A Curious Cumulation of CUDA Cuisine 16 | - :thumbsup:[StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) Statically sized arrays for Julia 17 | - [LuxurySparse.jl](https://github.com/QuantumBFS/LuxurySparse.jl) High performance extensions for sparse matrices. 18 | 19 | #### Large Sparse Matrix Eigensolvers 20 | - [IterativeSolvers.jl](https://github.com/JuliaMath/IterativeSolvers.jl) Iterative algorithms for solving linear systems, eigensystems, and singular value problems 21 | - :thumbsup:[KrylovKit.jl](https://github.com/Jutho/KrylovKit.jl) A Julia package collecting a number of Krylov-based algorithms for linear problems, singular value and eigenvalue problems and the application of functions of linear maps or operators to vectors. 22 | - [JacobiDavidson.jl](https://github.com/haampie/JacobiDavidson.jl) An implementation of Jacobi-Davidson in Julia. 23 | - [ArnoldiMethod.jl](https://github.com/haampie/ArnoldiMethod.jl) The Implicitly Restarted Arnoldi Method, natively in Julia. 24 | - [Krylov.jl](https://github.com/JuliaSmoothOptimizers/Krylov.jl): part of the 25 | [JuliaSmoothOptimizers](https://github.com/JuliaSmoothOptimizers) organisation, solves linear systems and least square problems, specific for linear operators from 26 | [LinearOperators.jl](https://github.com/JuliaSmoothOptimizers/LinearOperators.jl). 27 | - [KrylovMethods.jl](https://github.com/lruthotto/KrylovMethods.jl): specific for sparse matrices 28 | 29 | #### Others 30 | - :thumbsup:[Expokit.jl](https://github.com/acroy/Expokit.jl) This package provides Julia implementations of some routines contained in [EXPOKIT](http://www.maths.uq.edu.au/expokit). 31 | - [ExpmV.jl](https://github.com/matteoacrossi/ExpmV.jl) This is a Julia translation of the MATLAB implementation of Al-Mohy and Higham's function for computing expm(t*A)*v when A is sparse, without explicitly computing expm(A). 32 | 33 | - [JuMP.jl](https://github.com/JuliaOpt/JuMP.jl) Modeling language for Mathematical Optimization (linear, mixed-integer, conic, semidefinite, nonlinear) 34 | - [LowRankModels.jl](https://github.com/madeleineudell/LowRankModels.jl) LowRankModels.jl is a julia package for modeling and fitting generalized low rank models. 35 | 36 | ### Mathematics and Physics 37 | - [Cliffords.jl](https://github.com/BBN-Q/Cliffords.jl) Efficient calculation of Clifford circuits in Julia. 38 | - :thumbsup:[StatsBase.jl](https://github.com/JuliaStats/StatsBase.jl) StatsBase.jl is a Julia package that provides basic support for statistics. 39 | - [Symata.jl](https://github.com/jlapeyre/Symata.jl) language for symbolic mathematics 40 | 41 | - :thumbsup:[Yao.jl](https://github.com/QuantumBFS/Yao.jl) Extensible, Efficient Quantum Algorithm Design for Humans. 42 | - [QuantumLab.jl](https://github.com/vonDonnerstein/QuantumLab.jl) A workbench for Quantum Chemistry and Quantum Physics in Julia 43 | - [QuantumOptics.jl](https://github.com/qojulia/QuantumOptics.jl) Library for the numerical simulation of closed as well as open quantum systems. 44 | 45 | ### Deep Learning 46 | #### Frameworks 47 | - :thumbsup:[Knet.jl](https://github.com/denizyuret/Knet.jl) Koç University deep learning framework. 48 | - [TensorFlow.jl](https://github.com/malmaud/TensorFlow.jl) A Julia wrapper for TensorFlow 49 | - [MXNet.jl](https://github.com/dmlc/MXNet.jl) MXNet Julia Package - flexible and efficient deep learning in Julia 50 | 51 | #### Auto Differentiation 52 | - [ForwardDiff.jl](https://github.com/JuliaDiff/ForwardDiff.jl) Forward Mode Automatic Differentiation for Julia 53 | - [ReverseDiffSource.jl](https://github.com/JuliaDiff/ReverseDiffSource.jl) Reverse automated differentiation from source 54 | - [AutoDiffSource.jl](https://github.com/gaika/AutoDiffSource.jl) Julia automatic differentiation with source code transformation 55 | 56 | #### Others 57 | - [MLKernels.jl](https://github.com/trthatcher/MLKernels.jl) A Julia package for Mercer kernel functions (or the covariance functions used in Gaussian processes) that are used in the kernel methods of machine learning 58 | 59 | ### Data Science 60 | #### Data Structure 61 | - [LightGraphs.jl](https://github.com/JuliaGraphs/LightGraphs.jl) An optimized graphs package for Julia 62 | - [AbstractTrees.jl](https://github.com/Keno/AbstractTrees.jl) Abstract julia interfaces for working with trees 63 | - [Dendriform.jl](https://github.com/chakravala/Dendriform.jl) Dendriform di-algebra algorithms to compute using Loday's arithmetic on groves of planar binary trees. 64 | 65 | #### Data Compression and Storage 66 | - [JLD.jl](https://github.com/JuliaIO/JLD.jl) Saving and loading julia variables while preserving native types 67 | - [JLD2.jl](https://github.com/simonster/JLD2.jl) HDF5-compatible file format in pure Julia 68 | 69 | #### Data Visualization 70 | - [Interact.jl](https://github.com/JuliaGizmos/Interact.jl) Interactive widgets to play with your Julia code 71 | - [Plots.jl](https://github.com/JuliaPlots/Plots.jl) Powerful convenience for Julia visualizations and data analysis 72 | - :thumbsup:[PyPlot.jl](https://github.com/JuliaPy/PyPlot.jl) This module provides a Julia interface to the Matplotlib plotting library from Python, and specifically to the matplotlib.pyplot module. 73 | 74 | ### Other Developer's Tools 75 | - :thumbsup:[BenchmarkTools.jl](https://github.com/JuliaCI/BenchmarkTools.jl) BenchmarkTools makes performance tracking of Julia code easy by supplying a framework for writing and running groups of benchmarks as well as comparing benchmark results. 76 | - [PackageCompiler.jl](https://github.com/JuliaLang/PackageCompiler.jl) Compile your Julia Package 77 | - [StatProfilerHTML.jl](https://github.com/tkluck/StatProfilerHTML.jl) Show Julia profiling data in an explorable HTML page 78 | - [Cxx.jl](https://github.com/Keno/Cxx.jl) The Julia C++ Interface 79 | - :thumbsup:[PyCall.jl](https://github.com/JuliaPy/PyCall.jl) This package provides the ability to directly call and fully interoperate with Python from the Julia language. 80 | - :thumbsup:[Lazy.jl](https://github.com/MikeInnes/Lazy.jl) provides Julia with the cornerstones of functional programming 81 | 82 | -------------------------------------------------------------------------------- /data/barcode.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QuantumBFS/JuliaChallenge/32cb905569b52466d85c1d879128c22ebaa32662/data/barcode.png -------------------------------------------------------------------------------- /data/goblin.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/QuantumBFS/JuliaChallenge/32cb905569b52466d85c1d879128c22ebaa32662/data/goblin.png -------------------------------------------------------------------------------- /environment.yml: -------------------------------------------------------------------------------- 1 | dependencies: 2 | - pip 3 | - pip: 4 | - julia 5 | 6 | -------------------------------------------------------------------------------- /programs/fsa.f90: -------------------------------------------------------------------------------- 1 | ! initialize a random seed from the system clock at every run (fortran 95 code) 2 | subroutine init_random_seed() 3 | INTEGER :: i, n, clock 4 | INTEGER, DIMENSION(:), ALLOCATABLE :: seed 5 | 6 | CALL RANDOM_SEED(size = n) 7 | ALLOCATE(seed(n)) 8 | CALL SYSTEM_CLOCK(COUNT=clock) 9 | seed = clock + 37 * (/ (i - 1, i = 1, n) /) 10 | CALL RANDOM_SEED(PUT = seed) 11 | DEALLOCATE(seed) 12 | end subroutine init_random_seed 13 | 14 | !Perform Simulated Annealing using Metropolis updates for the single run. 15 | ! 16 | !Parameters: 17 | ! :ann: , the app. 18 | ! :initial_config: config, 19 | ! :tempscales: 1D array, the time scale from high temperature to low temperature. 20 | ! 21 | !Return: 22 | ! (minimum cost, optimal configuration) 23 | subroutine anneal_singlerun(config,field,opt_cost,opt_config) 24 | use problem 25 | implicit none 26 | integer,intent(inout) :: config(num_spin) 27 | real,intent(inout) :: field(num_spin) 28 | integer :: it,ispin,m 29 | real :: cost,delta 30 | real :: uni01(nms),beta 31 | integer,intent(out) :: opt_config(num_spin) 32 | real,intent(out) :: opt_cost 33 | 34 | opt_config=config 35 | call get_cost(config,cost) 36 | opt_cost=cost 37 | 38 | do it=1,num_tempscales 39 | beta=1/tempscales(it) 40 | call random_number(uni01) 41 | do m=1,nms 42 | call propose(config,field,ispin,delta) 43 | if(exp(-beta*delta)>uni01(m)) then !accept 44 | call accept(ispin,config,field) 45 | cost=cost+delta 46 | if(cost, the app. 71 | :initial_state: state, 72 | :tempscales: 1D array, the time scale from high temperature to low temperature. 73 | :nms: int, the number of Monte Carlo updates in each time scale. 74 | 75 | Return: 76 | (minimum cost, optimal configuration) 77 | ''' 78 | state=initial_state 79 | opt_state=copy.deepcopy(initial_state) 80 | opt_cost=cost=ann.get_cost(state) 81 | for T in tempscales: 82 | uni01=random.random(nms) 83 | beta=1./T 84 | for m in range(nms): 85 | info,dE=ann.propose(state) 86 | if exp(-beta*dE)>uni01[m]: #accept 87 | state=ann.accept((info,dE),state) 88 | cost+=dE 89 | if cost, the app. 99 | :tempscales: 1D array, the time scale from high temperature to low temperature. 100 | :nrun: int, the number of runs. 101 | :nms: int, the number of Monte Carlo updates in each time scale. 102 | 103 | Return: 104 | (minimum cost, optimal configuration) 105 | ''' 106 | opt_cost=Inf 107 | for r in range(nrun): 108 | t0=time.time() 109 | initial_state=ann.get_random_state() 110 | cost,state=anneal_singlerun(ann,initial_state,tempscales,nms=nms) 111 | if cost %s'%(r,cost,t1-t0)) 116 | return opt_cost,opt_state 117 | 118 | ''' 119 | Flexible way to construct . 120 | 121 | e.g. sap(get_cost,propose,accept,get_random_state) 122 | ''' 123 | sap=namedtuple('SAP','get_cost propose accept get_random_state') 124 | -------------------------------------------------------------------------------- /programs/testsa.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Tests for nrg. 3 | ''' 4 | from numpy import * 5 | from numpy.testing import dec,assert_,assert_raises,assert_almost_equal,assert_allclose 6 | from scipy.sparse import coo_matrix 7 | import pdb,sys, os 8 | 9 | from sa import SAP,anneal 10 | 11 | class CC(SAP): 12 | def __init__(self,J): 13 | self.J=J 14 | 15 | def get_cost(self,state): 16 | config=state[0] 17 | return (self.J*config[:,newaxis]*config).sum() 18 | 19 | def propose(self,state): 20 | config,field=state 21 | N=len(self.J) 22 | i = random.randint(N) 23 | dE=-field[i]*config[i]*4 #2 for spin change, 2 for mutual energy. 24 | return i,dE 25 | 26 | def accept(self,proposal,state): 27 | i,dE=proposal 28 | config,field=state 29 | config[i]*=-1 30 | #update field 31 | ci=config[i] 32 | field+=(2*ci)*self.J[:,i] 33 | return (config,field) 34 | 35 | def get_random_state(self): 36 | config=sign(random.random(len(self.J))-0.5) 37 | field=self.J.dot(config) 38 | return (config,field) 39 | 40 | def test_codec(): 41 | #run a simple test: code challenge 42 | N=300 43 | data=loadtxt(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'example.txt')) 44 | J=coo_matrix((data[:,2],(data[:,0],data[:,1])),shape=(N,N),dtype='int32').toarray() 45 | J=(J+J.T)/2. 46 | cc=CC(J) 47 | Emin,Config=anneal(cc,tempscales=linspace(10,0.6,51),nms=4000,nrun=30) 48 | assert_(Emin==-3858 and cc.get_cost(Config)==Emin) 49 | 50 | if __name__=='__main__': 51 | test_codec() 52 | -------------------------------------------------------------------------------- /simulated_annealing-Solution.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Load data file\n", 8 | "\n", 9 | "### Target: Fix comments with `#!`" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "using DelimitedFiles, Test, BenchmarkTools, Statistics\n", 19 | "\n", 20 | "\"\"\"General Annealing Problem\"\"\"\n", 21 | "abstract type AnnealingProblem end\n", 22 | "\n", 23 | "\"\"\"\n", 24 | " SpinAnnealingProblem{T<:Real} <: AnnealingProblem\n", 25 | "\n", 26 | "Annealing problem defined by coupling matrix of spins.\n", 27 | "\"\"\"\n", 28 | "struct SpinAnnealingProblem{T<:Real} <: AnnealingProblem # immutable, with type parameter T (a subtype of Real).\n", 29 | " num_spin::Int\n", 30 | " coupling::Matrix{T}\n", 31 | " function SpinAnnealingProblem(coupling::Matrix{T}) where T\n", 32 | " size(coupling, 1) == size(coupling, 2) || throw(DimensionMismatch(\"input must be square matrix.\"))\n", 33 | " new{T}(size(coupling, 1), coupling)\n", 34 | " end\n", 35 | "end\n", 36 | "\n", 37 | "\"\"\"\n", 38 | " load_coupling(filename::String) -> SpinAnnealingProblem\n", 39 | "\n", 40 | "Load the data file into symmtric coupling matrix.\n", 41 | "\"\"\"\n", 42 | "function load_coupling(filename::String)\n", 43 | " data = readdlm(filename)\n", 44 | " is = Int.(view(data, :, 1)) .+ 1 #! @. means broadcast for the following functions, is here used correctly?\n", 45 | " js = Int.(view(data, :, 2)) .+ 1\n", 46 | " weights = data[:,3]\n", 47 | " num_spin = max(maximum(is), maximum(js))\n", 48 | " J = zeros(eltype(weights), num_spin, num_spin)\n", 49 | " @inbounds for (i, j, weight) = zip(is, js, weights)\n", 50 | " J[i,j] = weight/2\n", 51 | " J[j,i] = weight/2\n", 52 | " end\n", 53 | " SpinAnnealingProblem(J)\n", 54 | "end" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "metadata": {}, 61 | "outputs": [], 62 | "source": [ 63 | "@testset \"loading\" begin\n", 64 | " sap = load_coupling(\"programs/example.txt\")\n", 65 | " @test size(sap.coupling) == (300, 300)\n", 66 | "end" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "abstract type AnnealingConfig end\n", 76 | "\n", 77 | "struct SpinConfig{Ts, Tf} <: AnnealingConfig\n", 78 | " config::Vector{Ts}\n", 79 | " field::Vector{Tf}\n", 80 | "end\n", 81 | "\n", 82 | "\"\"\"\n", 83 | " random_config(prblm::AnnealingProblem) -> SpinConfig\n", 84 | "\n", 85 | "Random spin configuration.\n", 86 | "\"\"\"\n", 87 | "function random_config end # where to put the docstring of a multiple-dispatch function is a problem. Using `abstract function` is proper.\n", 88 | "\n", 89 | "function random_config(prblm::SpinAnnealingProblem)\n", 90 | " config = rand([-1,1], prblm.num_spin)\n", 91 | " SpinConfig(config, prblm.coupling*config)\n", 92 | "end" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "metadata": {}, 99 | "outputs": [], 100 | "source": [ 101 | "@testset \"random config\" begin\n", 102 | " sap = load_coupling(\"programs/example.txt\")\n", 103 | " initial_config = random_config(sap)\n", 104 | " @test initial_config.config |> length == 300\n", 105 | " @test eltype(initial_config.config) == Int\n", 106 | "end" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "# Main Program for Annealing" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [ 122 | "\"\"\"\n", 123 | " anneal_singlerun!(config::AnnealingConfig, prblm, tempscales::Vector{Float64}, num_update_each_temp::Int)\n", 124 | "\n", 125 | "Perform Simulated Annealing using Metropolis updates for the single run.\n", 126 | "\n", 127 | " * configuration that can be updated.\n", 128 | " * prblm: problem with `get_cost`, `flip!` and `random_config` interfaces.\n", 129 | " * tempscales: temperature scales, which should be a decreasing array.\n", 130 | " * num_update_each_temp: the number of update in each temprature scale.\n", 131 | "\n", 132 | "Returns (minimum cost, optimal configuration).\n", 133 | "\"\"\"\n", 134 | "function anneal_singlerun!(config, prblm, tempscales::Vector{Float64}, num_update_each_temp::Int)\n", 135 | " cost = get_cost(config, prblm)\n", 136 | " \n", 137 | " opt_config = config\n", 138 | " opt_cost = cost\n", 139 | " for beta = 1 ./ tempscales\n", 140 | " @simd for m = 1:num_update_each_temp # single instriuction multiple data, see julia performance tips.\n", 141 | " proposal, ΔE = propose(config, prblm)\n", 142 | " if exp(-beta*ΔE) > rand() #accept\n", 143 | " flip!(config, proposal, prblm)\n", 144 | " cost += ΔE\n", 145 | " if cost < opt_cost\n", 146 | " opt_cost = cost\n", 147 | " opt_config = config\n", 148 | " end\n", 149 | " end\n", 150 | " end\n", 151 | " end\n", 152 | " opt_cost, opt_config\n", 153 | "end\n", 154 | " \n", 155 | "\"\"\"\n", 156 | " anneal(nrun::Int, prblm, tempscales::Vector{Float64}, num_update_each_temp::Int)\n", 157 | "\n", 158 | "Perform Simulated Annealing with multiple runs.\n", 159 | "\"\"\"\n", 160 | "function anneal(nrun::Int, prblm, tempscales::Vector{Float64}, num_update_each_temp::Int)\n", 161 | " local opt_config, opt_cost\n", 162 | " for r = 1:nrun\n", 163 | " initial_config = random_config(prblm)\n", 164 | " cost, config = anneal_singlerun!(initial_config, prblm, tempscales, num_update_each_temp)\n", 165 | " if r == 1 || cost < opt_cost\n", 166 | " opt_cost = cost\n", 167 | " opt_config = config\n", 168 | " end\n", 169 | " end\n", 170 | " opt_cost, opt_config\n", 171 | "end" 172 | ] 173 | }, 174 | { 175 | "cell_type": "markdown", 176 | "metadata": {}, 177 | "source": [ 178 | "# Annealing Problem Interfaces" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": {}, 185 | "outputs": [], 186 | "source": [ 187 | "\"\"\"\n", 188 | " get_cost(config::AnnealingConfig, ap::AnnealingProblem) -> Real\n", 189 | "\n", 190 | "Get the cost of specific configuration.\n", 191 | "\"\"\"\n", 192 | "get_cost(config::SpinConfig, sap::SpinAnnealingProblem) = sum(config.config'*sap.coupling*config.config)\n", 193 | "\n", 194 | "\"\"\"\n", 195 | " propose(config::AnnealingConfig, ap::AnnealingProblem) -> (Proposal, Real)\n", 196 | "\n", 197 | "Propose a change, as well as the energy change.\n", 198 | "\"\"\"\n", 199 | "@inline function propose(config::SpinConfig, ::SpinAnnealingProblem) # ommit the name of argument, since not used.\n", 200 | " ispin = rand(1:length(config.config))\n", 201 | " @inbounds ΔE = -config.field[ispin] * config.config[ispin] * 4 # 2 for spin change, 2 for mutual energy.\n", 202 | " ispin, ΔE\n", 203 | "end\n", 204 | "\n", 205 | "\"\"\"\n", 206 | " flip!(config::AnnealingConfig, ispin::Proposal, ap::AnnealingProblem) -> SpinConfig\n", 207 | "\n", 208 | "Apply the change to the configuration.\n", 209 | "\"\"\"\n", 210 | "@inline function flip!(config::SpinConfig, ispin::Int, sap::SpinAnnealingProblem)\n", 211 | " @inbounds config.config[ispin] = -config.config[ispin] # @inbounds can remove boundary check, and improve performance\n", 212 | " @simd for i=1:sap.num_spin\n", 213 | " @inbounds config.field[i] += 2 * config.config[ispin] * sap.coupling[i,ispin]\n", 214 | " end\n", 215 | " config\n", 216 | "end" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": {}, 222 | "source": [ 223 | "### **Challege!**\n", 224 | "Make your program correct and type is stable!" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": null, 230 | "metadata": {}, 231 | "outputs": [], 232 | "source": [ 233 | "using Random\n", 234 | "Random.seed!(2)\n", 235 | "const tempscales = 10 .- (1:64 .- 1) .* 0.15 |> collect\n", 236 | "const sap = load_coupling(\"programs/example.txt\")" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": null, 242 | "metadata": {}, 243 | "outputs": [], 244 | "source": [ 245 | "@testset \"anneal\" begin\n", 246 | " opt_cost, opt_config = anneal(30, sap, tempscales, 4000)\n", 247 | " @test anneal(30, sap, tempscales, 4000)[1] == -3858\n", 248 | " anneal(30, sap, tempscales, 4000)\n", 249 | " res = median(@benchmark anneal(30, $sap, $tempscales, 4000))\n", 250 | " @test res.time/1e9 < 2\n", 251 | " @test res.allocs < 500\n", 252 | "end" 253 | ] 254 | }, 255 | { 256 | "cell_type": "code", 257 | "execution_count": null, 258 | "metadata": {}, 259 | "outputs": [], 260 | "source": [ 261 | "@benchmark anneal(30, $sap, $tempscales, 4000)" 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "metadata": {}, 267 | "source": [ 268 | "# Tips for optimization: Find the bottleneck of your program" 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": null, 274 | "metadata": {}, 275 | "outputs": [], 276 | "source": [ 277 | "using Profile\n", 278 | "Profile.clear()\n", 279 | "@profile anneal(100, sap, tempscales, 4000)\n", 280 | "Profile.print()" 281 | ] 282 | }, 283 | { 284 | "cell_type": "markdown", 285 | "metadata": {}, 286 | "source": [ 287 | "# Calling a Fortran program\n", 288 | "* https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/index.html\n", 289 | "* https://craftofcoding.wordpress.com/2017/02/26/calling-fortran-from-julia-i/\n", 290 | "* https://craftofcoding.wordpress.com/2017/03/01/calling-fortran-from-julia-ii/" 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": null, 296 | "metadata": {}, 297 | "outputs": [], 298 | "source": [ 299 | ";cd programs" 300 | ] 301 | }, 302 | { 303 | "cell_type": "code", 304 | "execution_count": null, 305 | "metadata": {}, 306 | "outputs": [], 307 | "source": [ 308 | ";gfortran -shared -fPIC problem.f90 fsa.f90 -o fsa.so" 309 | ] 310 | }, 311 | { 312 | "cell_type": "code", 313 | "execution_count": null, 314 | "metadata": {}, 315 | "outputs": [], 316 | "source": [ 317 | ";nm fsa.so" 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": null, 323 | "metadata": {}, 324 | "outputs": [], 325 | "source": [ 326 | "@benchmark ccall((:test_, \"fsa.so\"), Int32, ())" 327 | ] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "# For Python lovers?\n", 334 | "We can use [PyCall](https://github.com/JuliaPy/PyCall.jl) to call python programs!\n", 335 | "\n", 336 | "### **Challenge!**\n", 337 | "1. use Python package [viznet](https://github.com/GiggleLiu/viznet) and [matplotlib](https://matplotlib.org/) for visualization\n", 338 | "2. benchmark pure python version of simulated annealing, show the time" 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": null, 344 | "metadata": {}, 345 | "outputs": [], 346 | "source": [ 347 | "# pip install viznet, matplotlib\n", 348 | "using PyCall\n", 349 | "\n", 350 | "@pyimport viznet\n", 351 | "@pyimport matplotlib.pyplot as plt\n", 352 | "brush = viznet.NodeBrush(\"nn.input\")\n", 353 | "brush >> (0, 0)\n", 354 | "plt.axis([-1, 1, -1, 1])\n", 355 | "plt.axis(\"equal\")\n", 356 | "plt.axis(\"off\")\n", 357 | "plt.show()" 358 | ] 359 | }, 360 | { 361 | "cell_type": "code", 362 | "execution_count": null, 363 | "metadata": {}, 364 | "outputs": [], 365 | "source": [ 366 | "# we benchmark the `test_codec` function in file `testsa.py`\n", 367 | "pushfirst!(PyVector(pyimport(\"sys\")[\"path\"]), joinpath(@__DIR__, \"programs\")) # add current folder into path\n", 368 | "@pyimport testsa\n", 369 | "@benchmark testsa.test_codec()" 370 | ] 371 | }, 372 | { 373 | "cell_type": "code", 374 | "execution_count": null, 375 | "metadata": {}, 376 | "outputs": [], 377 | "source": [] 378 | } 379 | ], 380 | "metadata": { 381 | "kernelspec": { 382 | "display_name": "Julia 1.8.1", 383 | "language": "julia", 384 | "name": "julia-1.8" 385 | }, 386 | "language_info": { 387 | "file_extension": ".jl", 388 | "mimetype": "application/julia", 389 | "name": "julia", 390 | "version": "1.8.1" 391 | } 392 | }, 393 | "nbformat": 4, 394 | "nbformat_minor": 2 395 | } 396 | -------------------------------------------------------------------------------- /simulated_annealing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Load data file\n", 8 | "\n", 9 | "### Target: Fix comments with `#!`" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": null, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "using DelimitedFiles, Test, BenchmarkTools, Statistics\n", 19 | "\n", 20 | "\"\"\"General Annealing Problem\"\"\"\n", 21 | "abstract type AnnealingProblem end\n", 22 | "\n", 23 | "\"\"\"\n", 24 | " SpinAnnealingProblem{T<:Real} <: AnnealingProblem\n", 25 | "\n", 26 | "Annealing problem defined by coupling matrix of spins.\n", 27 | "\"\"\"\n", 28 | "struct SpinAnnealingProblem{T<:Real} <: AnnealingProblem # immutable, with type parameter T (a subtype of Real).\n", 29 | " num_spin::Int\n", 30 | " coupling::Matrix{T}\n", 31 | " function SpinAnnealingProblem(coupling::Matrix{T}) where T\n", 32 | " size(coupling, 1) == size(coupling, 2) || throw(DimensionMismatch(\"input must be square matrix.\"))\n", 33 | " new{T}(size(coupling, 1), coupling)\n", 34 | " end\n", 35 | "end\n", 36 | "\n", 37 | "\"\"\"\n", 38 | " load_coupling(filename::String) -> SpinAnnealingProblem\n", 39 | "\n", 40 | "Load the data file into symmtric coupling matrix.\n", 41 | "\"\"\"\n", 42 | "function load_coupling(filename::String)\n", 43 | " data = readdlm(filename)\n", 44 | " is = @. Int(view(data, :, 1)) + 1 #! @. means broadcast for the following functions, is here used correctly?\n", 45 | " js = @. Int(view(data, :, 2)) + 1\n", 46 | " weights = data[:,3]\n", 47 | " num_spin = max(maximum(is), maximum(js))\n", 48 | " J = zeros(eltype(weights), num_spin, num_spin)\n", 49 | " @inbounds for (i, j, weight) = zip(is, js, weights)\n", 50 | " J[i,j] = weight/2\n", 51 | " J[j,i] = weight/2\n", 52 | " end\n", 53 | " SpinAnnealingProblem(J)\n", 54 | "end" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "metadata": {}, 61 | "outputs": [], 62 | "source": [ 63 | "@testset \"loading\" begin\n", 64 | " sap = load_coupling(\"programs/example.txt\")\n", 65 | " @test size(sap.coupling) == (300, 300)\n", 66 | "end" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "abstract type AnnealingConfig end\n", 76 | "\n", 77 | "struct SpinConfig{Ts, Tf} <: AnnealingConfig\n", 78 | " config::Vector{Ts}\n", 79 | " field::Vector{Tf}\n", 80 | "end\n", 81 | "\n", 82 | "\"\"\"\n", 83 | " random_config(prblm::AnnealingProblem) -> SpinConfig\n", 84 | "\n", 85 | "Random spin configuration.\n", 86 | "\"\"\"\n", 87 | "function random_config end # where to put the docstring of a multiple-dispatch function is a problem. Using `abstract function` is proper.\n", 88 | "\n", 89 | "function random_config(prblm::SpinAnnealingProblem)\n", 90 | " config = rand([-1,1], prblm.num_spin)\n", 91 | " SpinConfig(config, prblm.coupling*config)\n", 92 | "end" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": null, 98 | "metadata": {}, 99 | "outputs": [], 100 | "source": [ 101 | "@testset \"random config\" begin\n", 102 | " sap = load_coupling(\"programs/example.txt\")\n", 103 | " initial_config = random_config(sap)\n", 104 | " @test initial_config.config |> length == 300\n", 105 | " @test eltype(initial_config.config) == Int\n", 106 | "end" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "# Main Program for Annealing" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [ 122 | "\"\"\"\n", 123 | " anneal_singlerun!(config::AnnealingConfig, prblm, tempscales::Vector{Float64}, num_update_each_temp::Int)\n", 124 | "\n", 125 | "Perform Simulated Annealing using Metropolis updates for the single run.\n", 126 | "\n", 127 | " * configuration that can be updated.\n", 128 | " * prblm: problem with `get_cost`, `flip!` and `random_config` interfaces.\n", 129 | " * tempscales: temperature scales, which should be a decreasing array.\n", 130 | " * num_update_each_temp: the number of update in each temprature scale.\n", 131 | "\n", 132 | "Returns (minimum cost, optimal configuration).\n", 133 | "\"\"\"\n", 134 | "function anneal_singlerun!(config, prblm, tempscales::Vector{Float64}, num_update_each_temp::Int)\n", 135 | " cost = get_cost(config, prblm)\n", 136 | " \n", 137 | " opt_config = config\n", 138 | " opt_cost = cost\n", 139 | " for beta = 1 / tempscales #! fix this line\n", 140 | " @simd for m = 1:num_update_each_temp # single instriuction multiple data, see julia performance tips.\n", 141 | " proposal, ΔE = propose(config, prblm)\n", 142 | " if exp(-beta*ΔE) > rand() #accept\n", 143 | " flip!(config, proposal, prblm)\n", 144 | " cost += ΔE\n", 145 | " if cost < opt_cost\n", 146 | " opt_cost = cost\n", 147 | " opt_config = config\n", 148 | " end\n", 149 | " end\n", 150 | " end\n", 151 | " end\n", 152 | " opt_cost, opt_config\n", 153 | "end\n", 154 | " \n", 155 | "\"\"\"\n", 156 | " anneal(nrun::Int, prblm, tempscales::Vector{Float64}, num_update_each_temp::Int)\n", 157 | "\n", 158 | "Perform Simulated Annealing with multiple runs.\n", 159 | "\"\"\"\n", 160 | "function anneal(nrun::Int, prblm, tempscales::Vector{Float64}, num_update_each_temp::Int)\n", 161 | " opt_cost=999999 #! here, this initialization of opt_cost will cause allocation, how to fix?\n", 162 | " local opt_config\n", 163 | " for r = 1:nrun\n", 164 | " initial_config = random_config(prblm)\n", 165 | " cost, config = anneal_singlerun!(initial_config, prblm, tempscales, num_update_each_temp)\n", 166 | " if r == 1 || cost < opt_cost\n", 167 | " opt_cost = cost\n", 168 | " opt_config = config\n", 169 | " end\n", 170 | " end\n", 171 | " opt_cost, opt_config\n", 172 | "end" 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "# Annealing Problem Interfaces" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": null, 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [ 188 | "\"\"\"\n", 189 | " get_cost(config::AnnealingConfig, ap::AnnealingProblem) -> Real\n", 190 | "\n", 191 | "Get the cost of specific configuration.\n", 192 | "\"\"\"\n", 193 | "get_cost(config::SpinConfig, sap::SpinAnnealingProblem) = sum(config.config'*sap.coupling*config.config)\n", 194 | "\n", 195 | "\"\"\"\n", 196 | " propose(config::AnnealingConfig, ap::AnnealingProblem) -> (Proposal, Real)\n", 197 | "\n", 198 | "Propose a change, as well as the energy change.\n", 199 | "\"\"\"\n", 200 | "@inline function propose(config::SpinConfig, ::SpinAnnealingProblem) # ommit the name of argument, since not used.\n", 201 | " ispin = rand(1:length(config.config))\n", 202 | " @inbounds ΔE = -config.field[ispin] * config.config[ispin] * 4 # 2 for spin change, 2 for mutual energy.\n", 203 | " ispin, ΔE\n", 204 | "end\n", 205 | "\n", 206 | "\"\"\"\n", 207 | " flip!(config::AnnealingConfig, ispin::Proposal, ap::AnnealingProblem) -> SpinConfig\n", 208 | "\n", 209 | "Apply the change to the configuration.\n", 210 | "\"\"\"\n", 211 | "@inline function flip!(config::SpinConfig, ispin::Int, sap::SpinAnnealingProblem)\n", 212 | " @inbounds config.config[ispin] = -config.config[ispin] # @inbounds can remove boundary check, and improve performance\n", 213 | " config.field .+= 2 .* config.config[ispin] .* sap.coupling[:,ispin] #! this line can be super inefficient! try to improve it\n", 214 | " config\n", 215 | "end" 216 | ] 217 | }, 218 | { 219 | "cell_type": "markdown", 220 | "metadata": {}, 221 | "source": [ 222 | "### **Challege!**\n", 223 | "Make your program correct and type is stable!" 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": null, 229 | "metadata": {}, 230 | "outputs": [], 231 | "source": [ 232 | "using Random\n", 233 | "Random.seed!(2)\n", 234 | "const tempscales = 10 .- (1:64 .- 1) .* 0.15 |> collect\n", 235 | "const sap = load_coupling(\"programs/example.txt\")" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": {}, 242 | "outputs": [], 243 | "source": [ 244 | "@testset \"anneal\" begin\n", 245 | " opt_cost, opt_config = anneal(30, sap, tempscales, 4000)\n", 246 | " @test anneal(30, sap, tempscales, 4000)[1] == -3858\n", 247 | " anneal(30, sap, tempscales, 4000)\n", 248 | " res = median(@benchmark anneal(30, $sap, $tempscales, 4000))\n", 249 | " @test res.time/1e9 < 2\n", 250 | " @test res.allocs < 500\n", 251 | "end" 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": {}, 258 | "outputs": [], 259 | "source": [ 260 | "@benchmark anneal(30, $sap, $tempscales, 4000)" 261 | ] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "metadata": {}, 266 | "source": [ 267 | "# Tips for optimization: Find the bottleneck of your program" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": null, 273 | "metadata": {}, 274 | "outputs": [], 275 | "source": [ 276 | "using Profile\n", 277 | "Profile.clear()\n", 278 | "@profile anneal(100, sap, tempscales, 4000)\n", 279 | "Profile.print()" 280 | ] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "# Calling a Fortran program\n", 287 | "* https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/index.html\n", 288 | "* https://craftofcoding.wordpress.com/2017/02/26/calling-fortran-from-julia-i/\n", 289 | "* https://craftofcoding.wordpress.com/2017/03/01/calling-fortran-from-julia-ii/" 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": null, 295 | "metadata": {}, 296 | "outputs": [], 297 | "source": [ 298 | ";cd programs" 299 | ] 300 | }, 301 | { 302 | "cell_type": "code", 303 | "execution_count": null, 304 | "metadata": {}, 305 | "outputs": [], 306 | "source": [ 307 | ";gfortran -shared -fPIC problem.f90 fsa.f90 -o fsa.so" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": null, 313 | "metadata": {}, 314 | "outputs": [], 315 | "source": [ 316 | ";nm fsa.so" 317 | ] 318 | }, 319 | { 320 | "cell_type": "code", 321 | "execution_count": null, 322 | "metadata": {}, 323 | "outputs": [], 324 | "source": [ 325 | "@benchmark ccall((:test_, \"fsa.so\"), Int32, ())" 326 | ] 327 | }, 328 | { 329 | "cell_type": "markdown", 330 | "metadata": {}, 331 | "source": [ 332 | "# For Python lovers?\n", 333 | "We can use [PyCall](https://github.com/JuliaPy/PyCall.jl) to call python programs!\n", 334 | "\n", 335 | "### **Challenge!**\n", 336 | "1. use Python package [viznet](https://github.com/GiggleLiu/viznet) and [matplotlib](https://matplotlib.org/) for visualization\n", 337 | "2. benchmark pure python version of simulated annealing, show the time" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": null, 343 | "metadata": {}, 344 | "outputs": [], 345 | "source": [ 346 | "# pip install viznet\n", 347 | "using PyCall\n", 348 | "\n", 349 | "@pyimport viznet\n", 350 | "@pyimport matplotlib.pyplot as plt\n", 351 | "brush = viznet.NodeBrush(\"nn.input\")\n", 352 | "brush >> (0, 0)\n", 353 | "plt.axis([-1, 1, -1, 1])\n", 354 | "plt.axis(\"equal\")\n", 355 | "plt.axis(\"off\")\n", 356 | "plt.show()" 357 | ] 358 | }, 359 | { 360 | "cell_type": "code", 361 | "execution_count": null, 362 | "metadata": {}, 363 | "outputs": [], 364 | "source": [ 365 | "# we benchmark the `test_codec` function in file `testsa.py`\n", 366 | "pushfirst!(PyVector(pyimport(\"sys\")[\"path\"]), joinpath(@__DIR__, \"programs\")) # add the program folder into path\n", 367 | "@pyimport testsa\n", 368 | "@benchmark testsa.test_codec()" 369 | ] 370 | }, 371 | { 372 | "cell_type": "code", 373 | "execution_count": null, 374 | "metadata": {}, 375 | "outputs": [], 376 | "source": [] 377 | } 378 | ], 379 | "metadata": { 380 | "kernelspec": { 381 | "display_name": "Julia 1.8.1", 382 | "language": "julia", 383 | "name": "julia-1.8" 384 | }, 385 | "language_info": { 386 | "file_extension": ".jl", 387 | "mimetype": "application/julia", 388 | "name": "julia", 389 | "version": "1.8.1" 390 | } 391 | }, 392 | "nbformat": 4, 393 | "nbformat_minor": 2 394 | } 395 | --------------------------------------------------------------------------------