Package evaluation to test SecureArithmetic on Julia 1.12.4 (01a2eadb04*) started at 2026-01-08T22:45:06.069 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 7.85s ################################################################################ # Installation # Installing SecureArithmetic... Resolving package versions... Updating `~/.julia/environments/v1.12/Project.toml` [38cee09b] + SecureArithmetic v0.2.1 Updating `~/.julia/environments/v1.12/Manifest.toml` [1f15a43c] + CxxWrap v0.17.4 [692b3bcd] + JLLWrappers v1.7.1 [1914dd2f] + MacroTools v0.5.16 [77ce9b8e] + OpenFHE v0.1.14 [21216c6a] + Preferences v1.5.1 [38cee09b] + SecureArithmetic v0.2.1 [1d63c593] + LLVMOpenMP_jll v18.1.8+0 [a89a0bdd] + OpenFHE_int128_jll v1.4.2+0 [a2687184] + OpenFHE_jll v1.4.2+0 [3eaa8342] + libcxxwrap_julia_jll v0.14.7+0 [328aa5c7] + openfhe_julia_int128_jll v0.5.0+0 [e5e97983] + openfhe_julia_jll v0.5.0+0 [56f22d72] + Artifacts v1.11.0 [ade2ca70] + Dates v1.11.0 [8f399da3] + Libdl v1.11.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [fa267f1f] + TOML v1.0.3 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1 Installation completed after 1.53s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... ┌ Error: Failed to use TestEnv.jl; test dependencies will not be precompiled │ exception = │ UndefVarError: `project_rel_path` not defined in `TestEnv` │ Suggestion: this global was defined as `Pkg.Operations.project_rel_path` but not assigned a value. │ Stacktrace: │ [1] get_test_dir(ctx::Pkg.Types.Context, pkgspec::PackageSpec) │ @ TestEnv ~/.julia/packages/TestEnv/iseFl/src/julia-1.11/common.jl:75 │ [2] test_dir_has_project_file │ @ ~/.julia/packages/TestEnv/iseFl/src/julia-1.11/common.jl:52 [inlined] │ [3] maybe_gen_project_override! │ @ ~/.julia/packages/TestEnv/iseFl/src/julia-1.11/common.jl:83 [inlined] │ [4] activate(pkg::String; allow_reresolve::Bool) │ @ TestEnv ~/.julia/packages/TestEnv/iseFl/src/julia-1.11/activate_set.jl:12 │ [5] activate(pkg::String) │ @ TestEnv ~/.julia/packages/TestEnv/iseFl/src/julia-1.11/activate_set.jl:9 │ [6] top-level scope │ @ /PkgEval.jl/scripts/precompile.jl:24 │ [7] include(mod::Module, _path::String) │ @ Base ./Base.jl:306 │ [8] exec_options(opts::Base.JLOptions) │ @ Base ./client.jl:317 │ [9] _start() │ @ Base ./client.jl:550 └ @ Main /PkgEval.jl/scripts/precompile.jl:26 Precompiling package dependencies... Precompiling packages... 12244.6 ms ✓ SecureArithmetic 1 dependency successfully precompiled in 12 seconds. 17 already precompiled. Precompilation completed after 25.13s ################################################################################ # Testing # Testing SecureArithmetic Status `/tmp/jl_ZXnx7Q/Project.toml` [77ce9b8e] OpenFHE v0.1.14 [38cee09b] SecureArithmetic v0.2.1 [8dfed614] Test v1.11.0 Status `/tmp/jl_ZXnx7Q/Manifest.toml` [1f15a43c] CxxWrap v0.17.4 [692b3bcd] JLLWrappers v1.7.1 [1914dd2f] MacroTools v0.5.16 [77ce9b8e] OpenFHE v0.1.14 [21216c6a] Preferences v1.5.1 [38cee09b] SecureArithmetic v0.2.1 [1d63c593] LLVMOpenMP_jll v18.1.8+0 [a89a0bdd] OpenFHE_int128_jll v1.4.2+0 [a2687184] OpenFHE_jll v1.4.2+0 [3eaa8342] libcxxwrap_julia_jll v0.14.7+0 [328aa5c7] openfhe_julia_int128_jll v0.5.0+0 [e5e97983] openfhe_julia_jll v0.5.0+0 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.12.0 [8f399da3] Libdl v1.11.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v0.7.0 [9e88b42a] Serialization v1.11.0 [f489334b] StyledStrings v1.11.0 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.3.0+1 Testing Running tests... SecureContext{SecureArithmetic.OpenFHEBackend}() [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0] (8,)-shaped PlainArray{OpenFHEBackend}: 0.25 0.5 0.75 1.0 2.0 3.0 4.0 5.0 SecureArithmetic.SecureVector{SecureArithmetic.OpenFHEBackend{CxxWrap.StdLib.SharedPtrAllocated{OpenFHE.CryptoContextImpl{OpenFHE.DCRTPoly}}}, Vector{CxxWrap.StdLib.SharedPtr{OpenFHE.CiphertextImpl{T}} where T}}(CxxWrap.StdLib.SharedPtr{OpenFHE.CiphertextImpl{T}} where T[Ciphertext{DCRTPoly}()], (8,), 8, SecureContext{SecureArithmetic.OpenFHEBackend}()) [0.25 0.5; 0.75 1.0; 2.0 3.0; 4.0 5.0] (4, 2)-shaped PlainArray{OpenFHEBackend}: 0.25 0.5 0.75 1.0 2.0 3.0 4.0 5.0 SecureArithmetic.SecureMatrix{SecureArithmetic.OpenFHEBackend{CxxWrap.StdLib.SharedPtrAllocated{OpenFHE.CryptoContextImpl{OpenFHE.DCRTPoly}}}, Vector{CxxWrap.StdLib.SharedPtr{OpenFHE.CiphertextImpl{T}} where T}}(CxxWrap.StdLib.SharedPtr{OpenFHE.CiphertextImpl{T}} where T[Ciphertext{DCRTPoly}()], (4, 2), 8, SecureContext{SecureArithmetic.OpenFHEBackend}()) [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0] (32,)-shaped PlainArray{OpenFHEBackend}: 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0 SecureArithmetic.SecureVector{SecureArithmetic.OpenFHEBackend{CxxWrap.StdLib.SharedPtrAllocated{OpenFHE.CryptoContextImpl{OpenFHE.DCRTPoly}}}, Vector{CxxWrap.StdLib.SharedPtr{OpenFHE.CiphertextImpl{T}} where T}}(CxxWrap.StdLib.SharedPtr{OpenFHE.CiphertextImpl{T}} where T[Ciphertext{DCRTPoly}(), Ciphertext{DCRTPoly}(), Ciphertext{DCRTPoly}(), Ciphertext{DCRTPoly}()], (32,), 32, SecureContext{SecureArithmetic.OpenFHEBackend}()) PublicKey{SecureArithmetic.OpenFHEBackend}() PrivateKey{SecureArithmetic.OpenFHEBackend}() SecureContext{SecureArithmetic.Unencrypted}() [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0] (8,)-shaped PlainArray{Unencrypted}: 0.25 0.5 0.75 1.0 2.0 3.0 4.0 5.0 SecureArithmetic.SecureVector{SecureArithmetic.Unencrypted, Vector{Float64}}([0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0], (8,), 8, SecureContext{SecureArithmetic.Unencrypted}()) [0.25 0.5; 0.75 1.0; 2.0 3.0; 4.0 5.0] (4, 2)-shaped PlainArray{Unencrypted}: 0.25 0.5 0.75 1.0 2.0 3.0 4.0 5.0 SecureArithmetic.SecureMatrix{SecureArithmetic.Unencrypted, Matrix{Float64}}([0.25 0.5; 0.75 1.0; 2.0 3.0; 4.0 5.0], (4, 2), 8, SecureContext{SecureArithmetic.Unencrypted}()) [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0] (32,)-shaped PlainArray{Unencrypted}: 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0 11.0 12.0 13.0 14.0 15.0 16.0 17.0 18.0 19.0 20.0 21.0 22.0 23.0 24.0 25.0 26.0 27.0 28.0 29.0 30.0 31.0 32.0 SecureArithmetic.SecureVector{SecureArithmetic.Unencrypted, Vector{Float64}}([1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0, 32.0], (32,), 32, SecureContext{SecureArithmetic.Unencrypted}()) PublicKey{SecureArithmetic.Unencrypted}() PrivateKey{SecureArithmetic.Unencrypted}() ================================================================================ Creating OpenFHE context... CKKS scheme is using ring dimension 16384 ================================================================================ Creating unencrypted context... ================================================================================ simple_real_numbers with an OpenFHE context Input x1: [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0] Input x2: [5.0, 4.0, 3.0, 2.0, 1.0, 0.75, 0.5, 0.25] Results of homomorphic computations: x1 = [0.24999999999996814, 0.5000000000000149, 0.7499999999999862, 1.0000000000000226, 1.9999999999999805, 3.00000000000003, 3.9999999999999782, 5.000000000000012] x1 + x2 = [5.250000000000002, 4.50000000000002, 3.75000000000013, 2.9999999999999254, 3.0000000000000493, 3.7499999999998908, 4.499999999999986, 5.250000000000082] x1 - x2 = [-4.7500000000000036, -3.499999999999938, -2.249999999999961, -1.0000000000000127, 0.9999999999999356, 2.2499999999999263, 3.5000000000000195, 4.749999999999988] 4 * x1 = [1.000000000000223, 1.9999999999996998, 3.0000000000000053, 3.99999999999984, 7.999999999999464, 11.999999999998971, 16.000000000000384, 20.00000000000043] x1 * x2 = [1.250000000000113, 1.9999999999999163, 2.249999999999598, 1.9999999999999492, 2.0000000000001386, 2.249999999999931, 1.999999999999837, 1.2500000000001126] x1 shifted circularly by -1 = [0.500000000000079, 0.7499999999998845, 0.999999999999944, 2.0000000000000404, 3.0000000000000395, 4.000000000000021, 5.000000000000019, 0.2500000000000222] x1 shifted circularly by 2 = [3.999999999999945, 4.999999999999952, 0.24999999999996447, 0.49999999999999156, 0.7500000000000562, 0.999999999999984, 1.99999999999996, 3.0000000000000835] ================================================================================ simple_real_numbers with an Unencrypted context Input x1: [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0] Input x2: [5.0, 4.0, 3.0, 2.0, 1.0, 0.75, 0.5, 0.25] Results of homomorphic computations: x1 = [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0] x1 + x2 = [5.25, 4.5, 3.75, 3.0, 3.0, 3.75, 4.5, 5.25] x1 - x2 = [-4.75, -3.5, -2.25, -1.0, 1.0, 2.25, 3.5, 4.75] 4 * x1 = [1.0, 2.0, 3.0, 4.0, 8.0, 12.0, 16.0, 20.0] x1 * x2 = [1.25, 2.0, 2.25, 2.0, 2.0, 2.25, 2.0, 1.25] x1 shifted circularly by -1 = [0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0, 0.25] x1 shifted circularly by 2 = [4.0, 5.0, 0.25, 0.5, 0.75, 1.0, 2.0, 3.0] ================================================================================ Creating OpenFHE context... CKKS scheme is using ring dimension 4096 ================================================================================ Creating unencrypted context... ================================================================================ simple_ckks_bootstrapping with an OpenFHE context Input: [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0] Output after bootstrapping [0.2500000000000096, 0.4999999999999717, 0.7499999999999879, 0.9999999999999793, 2.000000000000016, 3.0000000000000115, 4.000000000000002, 4.999999999999986] ================================================================================ simple_ckks_bootstrapping with an Unencrypted context Input: [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0] Output after bootstrapping [0.25, 0.5, 0.75, 1.0, 2.0, 3.0, 4.0, 5.0] ================================================================================ Creating OpenFHE context... CKKS scheme is using ring dimension 4096 ================================================================================ Creating unencrypted context... ================================================================================ simple_matrix_operations with an OpenFHE context Input matrix m1: [0.25 0.5 0.75; 1.0 2.0 3.0; 4.0 5.0 6.0] Input matrix m2: [6.0 5.0 4.0; 3.0 2.0 1.0; 0.75 0.5 0.25] Results of homomorphic computations: m1 = [0.25000000000002015 0.499999999999997 0.7500000000000425; 0.9999999999999725 2.0000000000000027 3.0000000000000533; 4.000000000000012 4.999999999999986 6.000000000000027] m1 + m2 = [6.250000000000044 5.500000000000069 4.750000000000016; 4.000000000000034 3.999999999999968 4.000000000000123; 4.750000000000046 5.499999999999934 6.250000000000023] m1 - m2 = [-5.74999999999999 -4.500000000000033 -3.249999999999992; -2.000000000000038 -2.2676864908051632e-14 1.9999999999999716; 3.2499999999999796 4.500000000000044 5.749999999999979] 4 * m1 = [0.9999999999999525 2.0000000000000533 3.0000000000000595; 4.0000000000000755 7.999999999999966 12.000000000000089; 16.00000000000005 19.999999999999922 24.000000000000107] m1 * m2 = [1.5000000000000258 2.500000000000103 3.0000000000000977; 2.999999999999993 4.000000000000034 3.000000000000136; 3.0000000000000693 2.499999999999745 1.5000000000000142] m1 shifted circularly by (0, 1) = [0.7500000000000215 0.2500000000000059 0.5000000000000179; 3.00000000000004 0.9999999999999942 2.0000000000000075; 5.999999999999999 4.00000000000002 5.0] m1 shifted circularly by (1, -1) = [4.9999999999999964 6.0 4.000000000000024; 0.5000000000000155 0.7500000000000218 0.2500000000000031; 2.0000000000000018 3.000000000000041 0.999999999999997] m1 after bootstrapping [0.25000000000001643 0.5000000000000284 0.7500000000000173; 1.0000000000000004 1.9999999999999876 3.000000000000033; 4.000000000000011 4.999999999999988 6.0000000000000036] ================================================================================ simple_matrix_operations with an Unencrypted context Input matrix m1: [0.25 0.5 0.75; 1.0 2.0 3.0; 4.0 5.0 6.0] Input matrix m2: [6.0 5.0 4.0; 3.0 2.0 1.0; 0.75 0.5 0.25] Results of homomorphic computations: m1 = [0.25 0.5 0.75; 1.0 2.0 3.0; 4.0 5.0 6.0] m1 + m2 = [6.25 5.5 4.75; 4.0 4.0 4.0; 4.75 5.5 6.25] m1 - m2 = [-5.75 -4.5 -3.25; -2.0 0.0 2.0; 3.25 4.5 5.75] 4 * m1 = [1.0 2.0 3.0; 4.0 8.0 12.0; 16.0 20.0 24.0] m1 * m2 = [1.5 2.5 3.0; 3.0 4.0 3.0; 3.0 2.5 1.5] m1 shifted circularly by (0, 1) = [0.75 0.25 0.5; 3.0 1.0 2.0; 6.0 4.0 5.0] m1 shifted circularly by (1, -1) = [5.0 6.0 4.0; 0.5 0.75 0.25; 2.0 3.0 1.0] m1 after bootstrapping [0.25 0.5 0.75; 1.0 2.0 3.0; 4.0 5.0 6.0] ================================================================================ Creating OpenFHE context... CKKS scheme is using ring dimension 32 ================================================================================ Creating unencrypted context... ================================================================================ simple_array_operations with an OpenFHE context Input array a1: [1.0 4.0 7.0; 2.0 5.0 8.0; 3.0 6.0 9.0;;; 10.0 13.0 16.0; 11.0 14.0 17.0; 12.0 15.0 18.0;;; 19.0 22.0 25.0; 20.0 23.0 26.0; 21.0 24.0 27.0] Input array a2: [27.0 24.0 21.0; 26.0 23.0 20.0; 25.0 22.0 19.0;;; 18.0 15.0 12.0; 17.0 14.0 11.0; 16.0 13.0 10.0;;; 9.0 6.0 3.0; 8.0 5.0 2.0; 7.0 4.0 1.0] Results of homomorphic computations: a1 = [1.0000000000000022 4.000000000000001 7.0000000000000036; 2.0000000000000027 5.0 7.999999999999992; 2.9999999999999982 5.999999999999993 9.000000000000002;;; 9.999999999999996 13.000000000000004 16.000000000000004; 11.000000000000002 14.0 16.99999999999998; 11.999999999999996 15.000000000000004 17.999999999999986;;; 19.000000000000007 21.999999999999993 25.000000000000007; 19.999999999999982 22.99999999999999 26.000000000000014; 20.999999999999993 24.000000000000007 26.999999999999993] a1 + a2 = [28.0 28.0 28.0; 28.0 28.0 28.0; 28.0 28.0 28.0;;; 28.0 28.0 28.0; 28.0 28.0 27.999999999999993; 28.0 28.0 27.99999999999998;;; 28.000000000000007 28.00000000000001 28.000000000000007; 27.99999999999998 27.99999999999999 28.0; 27.999999999999993 28.000000000000007 28.000000000000007] a1 - a2 = [-25.999999999999993 -20.000000000000007 -13.999999999999991; -23.99999999999999 -18.0 -12.0; -22.0 -16.0 -10.0;;; -8.000000000000004 -2.0000000000000027 4.0000000000000115; -6.000000000000008 1.7763568394002505e-15 6.000000000000001; -3.9999999999999982 1.9999999999999822 7.9999999999999964;;; 9.999999999999993 15.999999999999995 22.0; 12.0 17.999999999999993 24.000000000000004; 14.000000000000002 19.999999999999993 26.0] 4 * a1 = [3.9999999999999822 15.999999999999972 28.00000000000001; 8.000000000000014 19.999999999999982 31.999999999999993; 11.999999999999996 23.999999999999993 35.999999999999986;;; 39.99999999999997 52.000000000000014 63.99999999999998; 43.99999999999997 56.00000000000001 68.00000000000007; 47.99999999999999 59.999999999999986 71.99999999999991;;; 76.0 87.99999999999997 99.99999999999999; 79.99999999999996 91.99999999999994 103.99999999999997; 84.0 96.00000000000001 107.99999999999994] a1 * a2 = [26.999999999999957 95.99999999999979 147.0; 52.00000000000008 114.99999999999991 159.99999999999991; 74.99999999999987 131.99999999999994 171.00000000000006;;; 179.99999999999991 194.99999999999997 191.99999999999986; 187.0 195.99999999999994 186.99999999999994; 191.9999999999999 195.0 179.99999999999983;;; 171.0 132.00000000000006 75.00000000000004; 160.0 114.99999999999979 52.000000000000085; 147.0 96.0000000000002 27.000000000000128] a1 shifted circularly by (0, 1, 0) = [6.999999999999998 0.9999999999999982 4.000000000000005; 8.000000000000009 2.0000000000000053 4.999999999999998; 9.000000000000005 3.000000000000008 5.999999999999995;;; 16.000000000000004 10.000000000000016 13.000000000000023; 17.000000000000007 10.999999999999996 14.000000000000002; 18.0 12.000000000000009 14.999999999999979;;; 25.000000000000007 19.000000000000014 22.00000000000002; 26.00000000000002 20.000000000000007 23.0; 27.00000000000002 21.0 24.00000000000002] a1 shifted circularly by (1, -1, 1) = [24.00000000000001 27.000000000000025 21.00000000000005; 21.999999999999964 25.00000000000001 18.999999999999993; 23.0 26.00000000000002 19.99999999999999;;; 5.999999999999997 9.000000000000004 3.0; 3.999999999999993 7.000000000000028 1.0000000000000107; 5.000000000000011 8.0 2.0000000000000124;;; 15.000000000000007 17.999999999999986 12.000000000000012; 13.000000000000014 16.000000000000007 10.000000000000027; 13.999999999999982 17.0 10.999999999999982] a1 after bootstrapping [1.0000000000000013 3.9999999999999973 7.0000000000000036; 2.0000000000000067 4.999999999999998 8.0; 2.999999999999999 6.0 8.999999999999995;;; 9.999999999999993 12.999999999999998 16.000000000000004; 10.999999999999996 13.999999999999993 17.0; 12.000000000000007 15.0 17.99999999999999;;; 19.0 22.000000000000007 25.000000000000007; 20.0 22.999999999999986 26.000000000000004; 20.999999999999996 23.99999999999999 26.999999999999993] ================================================================================ simple_array_operations with an Unencrypted context Input array a1: [1 4 7; 2 5 8; 3 6 9;;; 10 13 16; 11 14 17; 12 15 18;;; 19 22 25; 20 23 26; 21 24 27] Input array a2: [27 24 21; 26 23 20; 25 22 19;;; 18 15 12; 17 14 11; 16 13 10;;; 9 6 3; 8 5 2; 7 4 1] Results of homomorphic computations: a1 = [1 4 7; 2 5 8; 3 6 9;;; 10 13 16; 11 14 17; 12 15 18;;; 19 22 25; 20 23 26; 21 24 27] a1 + a2 = [28 28 28; 28 28 28; 28 28 28;;; 28 28 28; 28 28 28; 28 28 28;;; 28 28 28; 28 28 28; 28 28 28] a1 - a2 = [-26 -20 -14; -24 -18 -12; -22 -16 -10;;; -8 -2 4; -6 0 6; -4 2 8;;; 10 16 22; 12 18 24; 14 20 26] 4 * a1 = [4.0 16.0 28.0; 8.0 20.0 32.0; 12.0 24.0 36.0;;; 40.0 52.0 64.0; 44.0 56.0 68.0; 48.0 60.0 72.0;;; 76.0 88.0 100.0; 80.0 92.0 104.0; 84.0 96.0 108.0] a1 * a2 = [27 96 147; 52 115 160; 75 132 171;;; 180 195 192; 187 196 187; 192 195 180;;; 171 132 75; 160 115 52; 147 96 27] a1 shifted circularly by (0, 1, 0) = [7 1 4; 8 2 5; 9 3 6;;; 16 10 13; 17 11 14; 18 12 15;;; 25 19 22; 26 20 23; 27 21 24] a1 shifted circularly by (1, -1, 1) = [24 27 21; 22 25 19; 23 26 20;;; 6 9 3; 4 7 1; 5 8 2;;; 15 18 12; 13 16 10; 14 17 11] a1 after bootstrapping [1 4 7; 2 5 8; 3 6 9;;; 10 13 16; 11 14 17; 12 15 18;;; 19 22 25; 20 23 26; 21 24 27] Test Summary: | Pass Total Time SecureArithmetic.jl tests | 264 264 2m45.1s test_unit.jl | 260 260 1m32.0s OpenFHE | 131 131 1m16.2s generate_keys | 1 1 0.4s init_multiplication! | 1 1 0.1s init_rotation! | 8 8 8.8s PlainVector | 2 2 0.6s PlainMatrix | 1 1 0.2s PlainArray | 1 1 0.2s encrypt | 5 5 0.7s add | 15 15 2.1s subtract | 15 15 3.2s multiply | 15 15 2.5s negate | 3 3 0.6s circshift | 24 24 45.6s multithreading | 5 5 1.3s length | 3 3 0.0s size | 4 4 0.1s capacity | 6 6 0.0s ndims | 1 1 0.0s level | 6 6 1.1s collect | 3 3 0.0s show | 12 12 6.7s Unencrypted | 129 129 15.4s generate_keys | 1 1 0.0s init_multiplication! | 1 1 0.0s init_rotation! | 6 6 0.0s PlainVector | 2 2 0.0s PlainMatrix | 1 1 0.0s PlainArray | 1 1 0.0s encrypt | 5 5 0.1s add | 15 15 3.1s subtract | 15 15 4.7s multiply | 15 15 3.0s negate | 3 3 0.7s circshift | 24 24 3.0s multithreading | 5 5 0.0s length | 3 3 0.0s size | 4 4 0.1s capacity | 6 6 0.0s ndims | 1 1 0.0s level | 6 6 0.0s collect | 3 3 0.0s show | 12 12 0.3s test_examples.jl | 4 4 41.1s examples/simple_real_numbers.jl | 1 1 2.4s examples/simple_ckks_bootstrapping.jl | 1 1 11.9s examples/simple_matrix_operations.jl | 1 1 14.2s examples/simple_array_operations.jl | 1 1 12.5s 165.484432 seconds (42.38 M allocations: 2.269 GiB, 2.84% gc time, 64.47% compilation time: <1% of which was recompilation) Testing SecureArithmetic tests passed Testing completed after 171.69s PkgEval succeeded after 218.68s