licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | code | 11319 |
# Linear trapezoidal, Dose 100, Dosetime 0, no tau
refdict = Dict(
:Cmax => [
190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482
],
:Tmax => [
1
1
1.5
1
4
2.5
2.5
4
3
2
],
:Cdose => [
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
],
:Tlag => [0
0
0
0
0.5
0
0
0
0
0],
:Clast => [
112.846
85.241
67.901
97.625
110.778
69.501
58.051
74.437
93.44
42.191
],
:AUClast => [
9585.4218
10112.176
5396.5498
9317.8358
9561.26
6966.598
7029.5735
7110.6745
8315.0803
5620.8945
],
:AUMClast => [
333582.48
298701.39
186032.06
313955.9
315181.56
226977.06
219797.71
240526.05
277613.98
154893.06
],
:AUCall => [
9585.4218
10112.1760
5396.5498
9317.8358
9561.2600
6966.5980
7029.5735
7110.6745
8315.0803
5620.8945
],
:Rsq => [
0.78607696
0.99276359
0.81358898
0.91885869
0.85335995
0.95011904
0.97031231
0.94796904
0.94753789
0.88092269
],
:ARsq => [
0.71476928
0.99035145
0.77630678
0.83771737
0.82891994
0.92517856
0.96041642
0.92195356
0.92130684
0.86391165
],
:NpLZ => [
5
5
7
3
8
4
5
4
4
9
],
:Kel => [
0.0033847439
0.014106315
0.0032914304
0.0076953442
0.0068133279
0.0076922807
0.012458956
0.0089300798
0.0056458649
0.017189737
],
:HL => [
204.78571
49.137367
210.59148
90.073577
101.73401
90.109450057666
55.634451
77.619371
122.77077
40.323315
],
:Clast_pred => [
117.30578
82.53669
66.931057
100.76793
105.29832
71.939942
61.172702
75.604277
93.761762
38.810857
],
:AUCinf => [
42925.019
16154.93
26026.183
22004.078
25820.275
16001.76
11688.953
15446.21
24865.246
8075.3242
],
:AUCpct => [
77.669383
37.405019
79.26492
57.65405
62.969953
56.463551
39.861391
53.964925
66.559429
30.394194
],
:MRTlast => [
34.801023
29.538786
34.472406
33.69408
32.964438
32.58076
31.267574
33.826053
33.386807
27.556657
],
:MRTinf => [
293.16224
71.937917
305.04073
130.69968
149.96684
128.24114
79.498252
114.8571
176.97811
58.746446
],
:Clinf => [
0.0023296437
0.0061900608
0.0038422846
0.0045446122
0.0038729255
0.0062493127
0.0085550864
0.0064740799
0.0040216775
0.012383404
],
:Vzinf => [
0.68827768
0.43881487
1.1673601
0.59056646
0.56843374
0.8124135
0.68666158
0.72497447
0.71232266
0.72039519
],
)
# Linear up Log down, Dose 100, Dosetime 0.25, tau 9
refdict2 = Dict(
:Cmax => [
190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482
],
:Tmax => [
1
1
1.5
1
4
2.5
2.5
4
3
2
],
:Cdose => [
121.239
62.222
49.849
52.421
0
57.882
19.95
22.724
105.438
13.634
],
:Clast => [
112.846
85.241
67.901
97.625
110.778
69.501
58.051
74.437
93.44
42.191
],
:AUClast => [
9566.59680869131
10054.28647805950
5392.45721941379
9297.09633445033
9519.18087436122
6948.98562111745
6988.77263241364
7058.81896352039
8302.36808633358
5486.83888944199
],
:AUMCtau => [
5477.20423544297
8367.57088170951
3455.34643479800
6014.64604481587
6609.78830163090
5064.72384740413
4976.96365993911
2863.00517022791
5386.88322025614
4713.47970846693
],
:AUCall => [
9566.59680869131
10054.28647805950
5392.45721941379
9297.09633445033
9519.18087436122
6948.98562111745
6988.77263241364
7058.81896352039
8302.36808633358
5486.83888944199
],
:Rsq => [
0.786076957
0.992763591
0.81358898
0.918858685
0.853359952
0.95011904
0.970312315
0.94796904
0.947537895
0.88092269
],
:ARsq => [
0.714769276
0.990351454
0.776306776
0.83771737
0.828919944
0.92517856
0.96041642
0.92195356
0.921306842
0.863911645
],
# LZint
:LZint => [
5.00848559255328
5.42889759540296
4.44064607555325
5.16688496904739
5.14735707974283
4.82967584017057
5.01074587961482
4.96847859724365
4.94725938794774
4.89636108788302
],
:Kel => [
0.00338474394000776
0.01410631494324980
0.00329143037249282
0.00769534422298109
0.00681332791154901
0.00769228066663777
0.01245895597676470
0.00893007980967252
0.00564586491870971
0.01718973683041960
],
:HL => [
204.785706938398
49.137367437811
210.591476080649
90.073577019460
101.734011566509
90.109450057666
55.634451382012
77.619371308325
122.770769499451
40.323315440951
],
:Clast_pred => [
117.3057799
82.53668981
66.93105694
100.7679335
105.2983206
71.93994201
61.17270231
75.60427664
93.76176158
38.81085735
],
:AUCinf => [
42906.1941313004
16097.0411126277
26022.0900281352
21983.3384532182
25778.1957695968
15984.1473646863
11648.1518057779
15394.3547690766
24852.5337997128
7941.2685538530
],
:AUCpct => [
77.7034598328254
37.5395365663056
79.2773861992505
57.7084419901233
63.0727419426760
56.5257660444885
40.0010169085628
54.1467046238288
66.5934743183831
30.9072744205350
],
:MRTtauinf => [
299.791671096989
74.654997085457
305.919973652938
143.538421744963
173.022067431888
124.653434795141
92.735873637166
175.461862330056
178.810514188399
69.516339753006
],
:Cltau => [
0.078847213948573
0.054590500813083
0.132511872732088
0.074823364534525
0.076283206573122
0.089747243392665
0.092646906460213
0.130442680913677
0.081991954283052
0.103060243120434
],
:Vztau => [
23.2948829648816
3.8699335037324
40.2596615257358
9.7231991664617
11.1961742577834
11.6671826317919
7.4361693413954
14.6071125559694
14.5224789228203
5.9954520617241
],
:AUCtau => [
1268.27563070553
1831.82052757491
754.64936037981
1336.48093242129
1310.90451610924
1114.24035123260
1079.36685444479
766.62024499617
1219.63186357018
970.30626915116
],
)
################################################################################
# Linear Trapezoidal with Linear Interpolation, Dose 120, Dosetime 0.0, tau 12
refdict3 = Dict(
:Cmax => [190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482],
:Tmax => [1
1
1.5
1
4
2.5
2.5
4
3
2],
:Cdose => [0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0],
:Clast => [112.846
85.241
67.901
97.625
110.778
69.501
58.051
74.437
93.44
42.191],
:AUClast => [9585.4218
10112.176
5396.5498
9317.8358
9561.26
6966.598
7029.5735
7110.6745
8315.0803
5620.8945],
:AUMCtau => [9984.8168
14630.0690
6024.4953
10299.7210
11466.1230
8467.3568
9003.0193
6457.0058
10095.8180
8367.3005],
:AUCall => [9585.4218
10112.1760
5396.5498
9317.8358
9561.2600
6966.5980
7029.5735
7110.6745
8315.0803
5620.8945],
:Rsq => [0.78607696
0.99276359
0.81358898
0.91885869
0.86367664
0.95011904
0.97031231
0.94796904
0.94753789
0.87969895],
:ARsq => [0.71476928
0.99035145
0.77630678
0.83771737
0.84420187
0.92517856
0.96041642
0.92195356
0.92130684
0.86766884],
# LZint
:LZint => [5.0084856
5.4288976
4.4406461
5.166885
5.1496027
4.8296758
5.0107459
4.9684786
4.9472594
4.8651403],
:Kel => [0.0033847439
0.0141063150
0.0032914304
0.0076953442
0.0068579883
0.0076922807
0.0124589560
0.0089300798
0.0056458649
0.0165437520],
:HL => [204.785706938398
49.1373674378108
210.591476080649
90.0735770194602
101.071502239954
90.109450057666
55.6344513820121
77.6193713083247
122.770769499451
41.8978220179993],
:Clast_pred => [117.30578
82.53669
66.931057
100.76793
105.19623
71.939942
61.172702
75.604277
93.761762
39.408841],
:AUCinf => [42925.019
16154.93
26026.183
22004.078
25714.393
16001.76
11688.953
15446.21
24865.246
8171.1624],
:AUCpct => [77.669383
37.405019
79.26492
57.6540502829908
62.817478
56.463551
39.861391
53.964925
66.559429
31.210589],
:MRTtauinf => [302.40303
75.590599
312.72083
148.34069
172.0933
130.19061
91.908297
161.57402
176.30461
70.260736],
#Cltau, CLss
:Cltau => [0.07185191
0.050414459
0.12240579
0.070132959
0.06902661
0.085106504
0.083532913
0.10859036
0.073251565
0.092756742],
:Vztau => [21.228167
3.5738929
37.18924
9.113687
10.06514
11.063884
6.7046479
12.160066
12.974374
5.6067536],
:AUCtau => [1670.1018
2380.2695
980.34575
1711.0358
1738.46
1409.998
1436.5595
1105.0705
1638.1903
1293.7065],
)
################################################################################
#4 Log trapezoidal ATM, Dose 120, Dosetime 0, tau 12
refdict4 = Dict(
:Cmax => [
190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482
],
:Tmax => [
1
1
1.5
1
4
2.5
2.5
4
3
2
],
:Cdose => [
0
0
0
0
0
0
0
0
0
0
],
:Clast => [
112.846
85.241
67.901
97.625
110.778
69.501
58.051
74.437
93.44
42.191
],
:AUClast => [
9572.8582
10054.0367665966
5391.5322
9296.2179
9518.6531
6948.5757
6987.0645
7064.7816
8298.9634
5485.6538
],
:AUMCtau => [
9973.8062
14631.1197073321
6022.9286
10307.954
11473.081
8471.0956
8982.0378
6271.7444
10040.829690586
8361.7894
],
:AUCall => [
9572.8582
10054.0367665966
5391.5322
9296.2179
9518.6531
6948.5757
6987.0645
7064.7816
8298.9634
5485.6538
],
:Rsq => [
0.78607696
0.99276359
0.81358898
0.91885869
0.85335995
0.95011904
0.97031231
0.94796904
0.94753789
0.88092269
],
:ARsq => [
0.71476928
0.99035145
0.77630678
0.83771737
0.82891994
0.92517856
0.96041642
0.92195356
0.92130684
0.86391165
],
# LZint
:LZint => [
5.0084856
5.4288976
4.4406461
5.166885
5.1473571
4.8296758
5.0107459
4.9684786
4.9472594
4.8963611
],
:Kel => [
0.003384744
0.014106315
0.00329143
0.007695344
0.006813328
0.007692281
0.012458956
0.00893008
0.005645865
0.017189737
],
:HL => [
204.78571
49.137367
210.59148
90.073577
101.73401
90.109450057666
55.634451
77.619371
122.77077
40.323315
],
:Clast_pred => [
117.30578
82.53669
66.931057
100.76793
105.29832
71.939942
61.172702
75.604277
93.761762
38.810857
],
:AUCinf => [
42912.456
16096.791
26021.165
21982.4599914207
25777.668
15983.737
11646.444
15400.317
24849.129
7940.0834
],
:AUCpct => [
77.692122
37.540119
79.280204
57.710748
63.074033
56.527216
40.006884
54.12574
66.602599
30.911888
],
:MRTtauinf => [
302.63508
75.323724
313.06798
148.31081
172.5577
130.22554
91.866692
164.91799
176.98523
68.167555
],
:Cltau => [
0.071927102
0.050429351
0.12256044
0.070184147
0.069035447
0.0852177496596485
0.08379761
0.11110872
0.073575577
0.092819834
],
:Vztau => [
21.250382
3.5749486
37.236223
9.1203389
10.132412
11.078346
6.7258934
12.442074
13.031764
5.399724
],
:AUCtau => [
1668.3558
2379.5666
979.10878
1709.7878
1738.2375
1408.1573
1432.0218
1080.0233
1630.976
1292.8271
],
)
################################################################################
urefdict = Dict{Symbol, Float64}(
#:N_Samples => 5,
#:Dose => 100,
:Rsq => 0.90549162,
:ARsq => 0.81098324, #Rsq_adjusted
#:Corr_XY => -0.95157323,
#:No_points_lambda_z => 3,
:Kel => 0.13445441, #Lambda_z
#:Lambda_z_intercept => 0.79280975,
#:Lambda_z_lower => 4,
#:Lambda_z_upper => 15,
:HL => 5.1552579, #HL_Lambda_z
#:Span => 2.1337439,
#:Tlag => 0,
:Tmax => 1.5, #Tmax_Rate
:Maxrate => 4, #Max_Rate
#:Mid_Pt_last => 15,
:Rlast => 0.33333333, #Rate_last
#:Rate_last_pred => 0.2940497,
:AUClast => 17.125, #AURC_last
#:AURC_last_D => 0.17125,
:Vol => 11, #Vol_UR
:AR => 16, #Amount_Recovered
:Prec => 16, #Percent_Recovered
:AUCall => 17.125, #AURC_all
:AUCinf => 19.604155, #AURC_INF_obs
:AUCpct => 12.646069, #AURC_%Extrap_obs
#:AURC_INF_pred => 19.311984,
#:AURC_%Extrap_pred => 11.324493,
)
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | code | 37 | using MetidaNCA
include("tests.jl")
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | code | 48664 | #using MetidaNCA
using Test
using DataFrames, CSV, Plots, Unitful
import TypedTables: Table
path = dirname(@__FILE__)
io = IOBuffer();
pkdata2 = CSV.File(joinpath(path, "csv", "pkdata2.csv")) |> DataFrame
multtimepk = CSV.File(joinpath(path, "csv", "multtime.csv")) |> DataFrame
missingpk = CSV.File(joinpath(path, "csv", "missingpk.csv")) |> DataFrame
aucallpk = CSV.File(joinpath(path, "csv", "aucalltest.csv")) |> DataFrame
upkdata = CSV.File(joinpath(path, "csv", "upkdata.csv")) |> DataFrame
pddata = CSV.File(joinpath(path, "csv", "pddata.csv")) |> DataFrame
lloqpk = CSV.File(joinpath(path, "csv", "lloqpk.csv")) |> DataFrame
include("refdicts.jl")
# Cmax
# Tmax
# Cdose
# Tlag
# Clast
# AUClast
# AUMClast / AUMCtau
# AUCall
# Rsq
# Adjusted Rsq
# Kel
# HL
# LZint
# Clast_pred
# AUCinf
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
# MRTlast
# MRTinf / MRTtauinf
# MRTinf_pred
# Cllast
# Clinf / Cltau
# Vzlast
# Vzinf / Vztau
# Vssinf
# AUCtau
# Ctau
# Cavg
# Ctaumin
# Accind
# Fluc
# Fluctau
# Swing
# Swingtau
@testset " Basic API test " begin
# Basic dataset scenario
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
sort!(ds, :Subject)
show(io, ds)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :lint)
@test MetidaNCA.getid(dsnca, :, :Subject) == collect(1:10)
show(io, dsnca)
# pkimport method with keywords
@test_nowarn MetidaNCA.pkimport(pkdata2; time = :Time, conc = :Concentration)
# Export to tables
mtds = MetidaNCA.metida_table(ds)
mtdst = Table(ds)
@test size(mtds, 1) == size(pkdata2, 1)
dsncafromds = MetidaNCA.nca(pkdata2, :Time, :Concentration, [:Subject, :Formulation])
sort!(dsncafromds, :Subject)
@test dsnca[:, :AUClast] == dsncafromds[:, :AUClast]
# Plotting
# If typesort defined and NoPageSort() return one plot
pl = @test_nowarn MetidaNCA.pkplot(ds; typesort = :Subject, pagesort = MetidaNCA.NoPageSort(), sort = Dict(:Formulation => "R"))
@test isa(pl, Plots.Plot) == true
pl = @test_nowarn MetidaNCA.pkplot(ds; typesort = :Formulation, pagesort = MetidaNCA.NoPageSort(), legend = true)
@test isa(pl, Plots.Plot) == true
pl = @test_nowarn MetidaNCA.pkplot(ds; typesort = :Subject, sort = Dict(:Formulation => "R"), legend = true)
@test length(pl) == 10
pl = @test_nowarn MetidaNCA.pkplot(ds; typesort = :Formulation, legend = true)
@test length(pl) == 10
# If no typesort and no pagesort returns array of pairs id => plot
pl = @test_nowarn MetidaNCA.pkplot(ds; elim = true, ls = true)
@test length(pl) == 10
pl = @test_nowarn MetidaNCA.pkplot(ds; typesort = :Subject, pagesort = :Formulation, elim = true, ls = true, title = "Plots")
@test length(pl) == 2
pl = @test_nowarn MetidaNCA.pkplot(ds; typesort = :Formulation, pagesort = :Subject, xticksn = 8, yticksn = 10)
@test length(pl) == 10
# If MetidaNCA.NoPageSort() return one plot
pl = @test_nowarn MetidaNCA.pkplot(ds; pagesort = MetidaNCA.NoPageSort(), xticksn = 8, yticksn = 10)
@test isa(pl, Plots.Plot) == true
pl = @test_nowarn MetidaNCA.pkplot(ds; pagesort = [:Subject, :Formulation], legend = false)
@test length(pl) == 10
pl = @test_nowarn MetidaNCA.pkplot(ds; typesort = [:Subject, :Formulation], legend = true)
@test length(pl) == 10
pl = @test_nowarn MetidaNCA.pkplot(ds; typesort = [:Subject, :Formulation], pagesort = MetidaNCA.NoPageSort(), legend = true)
@test isa(pl, Plots.Plot) == true
# Return plot for PKSubject
@test_nowarn pl = MetidaNCA.pkplot(ds[1]; ylims = (0, 250), yscale = :log10, legend = false)
@test_nowarn pl = MetidaNCA.pkplot(ds[1]; elim = true, ls = false)
@test_nowarn MetidaNCA.plotstyle(40)
pl = MetidaNCA.pkplot(ds[3])
pl = MetidaNCA.pkplot!(ds[2]; yscale = :log10)
kr = MetidaNCA.ElimRange(kelstart = 4, kelend = 12, kelexcl = Int[5,6])
MetidaNCA.setkelrange!(ds, kr, [1,2,3])
dsnca = MetidaNCA.nca!(ds)
pl = @test_nowarn MetidaNCA.pkplot(ds[1]; elim = true)
MetidaNCA.setkelauto!(ds, true)
#Plot from NCA result DataSet
@test_nowarn MetidaNCA.pkplot(dsncafromds[1]; ylims = (0, 10), yscale = :log10, legend = false)
@test_nowarn MetidaNCA.pkplot(dsncafromds; typesort = :Subject, pagesort = :Formulation, elim = true, ls = true, title = "Plots")
# Unknown typesort
@test_nowarn pl = MetidaNCA.pkplot(ds; typesort = :unknown)
#pyplot()
#@test_nowarn pl = MetidaNCA.pkplot(ds[1]; ylims = (0, 10), yscale = :log2, legend = false)
#@test_nowarn pl = MetidaNCA.pkplot(ds[1]; ylims = (0, 10), yscale = :ln, legend = false)
# setdosetime!
MetidaNCA.setdosetime!(ds, MetidaNCA.DoseTime(dose = 100, time = 0.25))
@test first(MetidaNCA.nca!(ds)[:, :Cdose]) == 0
# Single subject scenario
tdat = pkdata2[1:16, :Time]
cdat = pkdata2[1:16, :Concentration]
ds = MetidaNCA.pkimport(tdat, cdat)
show(io, ds)
show(io, MetidaNCA.getdosetime(ds))
show(io, MetidaNCA.getkelrange(ds))
sbj = MetidaNCA.nca!(ds)
show(io, sbj)
show(io, MetidaNCA.getkeldata(sbj))
ct = MetidaNCA.ctmax(ds)
@test sbj[:Cmax] == ct[1]
@test sbj[:Tmax] == ct[2]
dsncafromds = MetidaNCA.nca(pkdata2[1:16, :], :Time, :Concentration)
@test sbj[:AUClast] ≈ dsncafromds[:AUClast]
dsncafromds = MetidaNCA.nca(tdat, cdat)
@test sbj[:AUClast] ≈ dsncafromds[:AUClast]
# Missing NaN
dsncafromds = MetidaNCA.nca(missingpk, :Time, :Concentration, io = io, verbose = 2, dosetime = MetidaNCA.DoseTime(dose = 100, time = 0, tau = 48))
@test sbj[:AUClast] ≈ dsncafromds[:AUClast]
auc048 = dsncafromds[:AUCtau]
missingpkl = deepcopy(missingpk)
missingpkl[18, :Concentration] = missing
dsncafromds = MetidaNCA.nca(missingpkl, :Time, :Concentration, io = io, verbose = 2)
@test auc048 ≈ dsncafromds[:AUClast]
# Missing string LLOQ
dsncafromds = MetidaNCA.nca(lloqpk, :Time, :Concentration, io = io, verbose = 2, warn = false)
@test sbj[:AUClast] ≈ dsncafromds[:AUClast]
dsncafromds = MetidaNCA.nca(missingpk, :Time, :Concentration, intpm = :luld, io = io, verbose = 2)
@test dsncafromds[:AUClast] ≈ 9585.189297075749
# Test wirh elimination range - start time is NaN
dsncafromds2 = MetidaNCA.nca(missingpk, :Time, :Concentration, intpm = :luld, io = io, verbose = 2, kelauto = false, elimrange = MetidaNCA.ElimRange(kelstart = 13, kelend = 18))
@test dsncafromds2[:AUClast] ≈ 9585.189297075749
dsncafromds = MetidaNCA.nca(missingpk, :Time, :Concentration;
limitrule = MetidaNCA.LimitRule(;lloq = 0, btmax = 0, atmax = NaN, nan = NaN, rm = true))
@test sbj[:AUClast] ≈ dsncafromds[:AUClast]
dsncafromds = MetidaNCA.pkimport(missingpk, :Time, :Concentration, :Subject;
limitrule = MetidaNCA.LimitRule(;lloq = 0, btmax = 0, atmax = NaN, nan = NaN, rm = true))
# Multiple time
@test_logs (:warn,"Not all time values is unique ([96.0, 4.0, 2.5]), last observation used! ((1,))") (:warn,"Some concentration values maybe not a number, try to fix.") ds = MetidaNCA.pkimport(multtimepk, :Time, :Concentration, :Subject)
dsmultt = MetidaNCA.pdimport(multtimepk, :Time, :Concentration, :Subject; warn = false)
@test MetidaNCA.gettime(dsmultt[1]) ≈ [0.0
0.5
1.0
1.5
2.0
2.5
3.0
4.0
5.0
6.0
8.0
10.0
12.0
24.0
48.0
72.0
96.0]
@test MetidaNCA.getobs(dsmultt[1]) ≈ [0.0
178.949
190.869
164.927
139.962
129.59
131.369
150.854
121.239
139.229
128.52
143.243
144.964
133.16
137.271
112.846
0.0]
# Apply modify! function
function newparam(data)
data.result[:AUChalf] = data.result[:AUClast] / 2
end
dsncafromds = MetidaNCA.nca(missingpk, :Time, :Concentration;
limitrule = MetidaNCA.LimitRule(;lloq = 0, btmax = 0, atmax = NaN, nan = NaN, rm = true), modify! = newparam)
dsncafromds[:AUChalf] ≈ dsncafromds[:AUClast] / 2
#redirect_stderr(Base.DevNull())
missingpk.ConcentrationStr = string.(missingpk.Concentration)
@test_logs (:warn, "Some concentration values maybe not a number, try to fix.") (:warn, "Value missing parsed as `NaN`") pkiw = MetidaNCA.pkimport(missingpk, :Time, :ConcentrationStr)
end
@testset " #1 Linear trapezoidal, Dose 100, Dosetime 0, no tau " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :lint)
@test MetidaNCA.cmax(MetidaNCA.gettime(ds[1]), MetidaNCA.getobs(ds[1])) == refdict[:Cmax][1]
@test MetidaNCA.tmax(MetidaNCA.gettime(ds[1]), MetidaNCA.getobs(ds[1])) == refdict[:Tmax][1]
@test round(MetidaNCA.auc(MetidaNCA.gettime(ds[1]), MetidaNCA.getobs(ds[1])), sigdigits = 8) == refdict[:AUCall][1]
# Cmax
@test dsnca[:, :Cmax] == refdict[:Cmax]
# Tmax
@test dsnca[:, :Tmax] == refdict[:Tmax]
# Cdose
@test round.(dsnca[:, :Cdose], sigdigits = 6) == round.(refdict[:Cdose], sigdigits = 6)
# Tlag
@test round.(dsnca[:, :Tlag], sigdigits = 6) == round.(refdict[:Tlag], sigdigits = 6)
# Clast
@test dsnca[:, :Clast] == refdict[:Clast]
# AUClast
@test round.(dsnca[:, :AUClast], sigdigits = 6) == round.(refdict[:AUClast], sigdigits = 6)
# AUMClast
@test round.(dsnca[:, :AUMClast], sigdigits = 6) == round.(refdict[:AUMClast], sigdigits = 6)
# AUCall
@test round.(dsnca[:, :AUCall], sigdigits = 6) == round.(refdict[:AUCall], sigdigits = 6)
# Rsq
@test round.(dsnca[:, :Rsq], digits = 6) == round.(refdict[:Rsq], digits = 6)
# Adjusted Rsq
@test round.(dsnca[:, :ARsq], digits = 6) == round.(refdict[:ARsq], digits = 6)
# NpLZ - Number points for Kel
@test round.(dsnca[:, :NpLZ], digits = 6) == round.(refdict[:NpLZ], digits = 6)
# Kel
@test round.(dsnca[:, :Kel], sigdigits = 6) == round.(refdict[:Kel], sigdigits = 6)
# HL
@test round.(dsnca[:, :HL], sigdigits = 5) == round.(refdict[:HL], sigdigits = 5)
# Clast_pred
@test round.(dsnca[:, :Clast_pred], sigdigits = 6) == round.(refdict[:Clast_pred], sigdigits = 6)
# AUCinf
@test round.(dsnca[:, :AUCinf], sigdigits = 6) == round.(refdict[:AUCinf], sigdigits = 6)
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
@test round.(dsnca[:, :AUCpct], sigdigits = 5) == round.(refdict[:AUCpct], sigdigits = 5)
# MRTlast
@test round.(dsnca[:, :MRTlast], digits = 6) == round.(refdict[:MRTlast], digits = 6)
# MRTinf
@test round.(dsnca[:, :MRTinf], digits = 5) == round.(refdict[:MRTinf], digits = 5)
# MRTinf_pred
# Cllast
# Clinf
@test round.(dsnca[:, :Clinf], sigdigits = 6) == round.(refdict[:Clinf], sigdigits = 6)
# Vzlast
# Vzinf
@test round.(dsnca[:, :Vzinf], sigdigits = 6) == round.(refdict[:Vzinf], sigdigits = 6)
# Vssinf
end
@testset " #2 Linear up Log down, Dose 100, Dosetime 0.25, tau 9 " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0.25, tau = 9))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld)
# Cmax
@test dsnca[:, :Cmax] == refdict2[:Cmax]
# Tmax
@test dsnca[:, :Tmax] == refdict2[:Tmax]
# Cdose
@test round.(dsnca[:, :Cdose], sigdigits = 6) == round.(refdict2[:Cdose], sigdigits = 6)
# Tlag
#=
@test round.(dsnca[:, :Tlag], sigdigits = 6) == round.([0
0
0
0
0.25
0
0
0
0
0], sigdigits = 6)
=#
# Clast
@test dsnca[:, :Clast] == refdict2[:Clast]
# AUClast
@test round.(dsnca[:, :AUClast], digits = 6) == round.(refdict2[:AUClast], digits = 6)
# AUMClast / AUMCtau
@test round.(dsnca[:, :AUMCtau], digits = 6) == round.(refdict2[:AUMCtau], digits = 6)
# AUCall
@test round.(dsnca[:, :AUCall], digits = 6) == round.(refdict2[:AUCall], digits = 6)
# Rsq
# Adjusted Rsq
# LZint
@test round.(dsnca[:, :LZint], digits = 6) == round.(refdict2[:LZint], digits = 6)
# Kel
@test round.(dsnca[:, :Kel], digits = 6) == round.(refdict2[:Kel], digits = 6)
# HL
@test round.(dsnca[:, :HL], digits = 6) == round.(refdict2[:HL], digits = 6)
# Clast_pred
@test round.(dsnca[:, :Clast_pred], digits = 6) == round.(refdict2[:Clast_pred], digits = 6)
# AUCinf
@test round.(dsnca[:, :AUCinf], digits = 6) == round.(refdict2[:AUCinf], digits = 6)
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
@test round.(dsnca[:, :AUCpct], digits = 6) == round.(refdict2[:AUCpct], digits = 6)
# MRTlast
# MRTinf / MRTtauinf
@test round.(dsnca[:, :MRTtauinf], digits = 6) == round.(refdict2[:MRTtauinf], digits = 6)
# MRTinf_pred
# Cllast
# Clinf / Cltau
@test round.(dsnca[:, :Cltau], digits = 6) == round.(refdict2[:Cltau], digits = 6)
# Vzlast
# Vzinf / Vztau
@test round.(dsnca[:, :Vztau], digits = 6) == round.(refdict2[:Vztau], digits = 6)
# Vssinf
# AUCtau
@test round.(dsnca[:, :AUCtau], digits = 6) == round.(refdict2[:AUCtau], digits = 6)
end
@testset " #3 Linear trapezoidal, IV, Dose 120, Dosetime 0.0, tau 12" begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 120, time = 0, tau = 12))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :iv, calcm = :lint)
# Cmax
@test dsnca[:, :Cmax] == refdict3[:Cmax]
# Tmax
@test dsnca[:, :Tmax] == refdict3[:Tmax]
# Cdose
@test round.(dsnca[:, :Cdose], sigdigits = 6) == round.(refdict3[:Cdose], sigdigits = 6)
# Tlag
#@test round.(dsnca[:, :Tlag], sigdigits = 6) == round.(refdict3[:Tlag], sigdigits = 6)
# Clast
@test dsnca[:, :Clast] == refdict3[:Clast]
# AUClast
@test round.(dsnca[:, :AUClast], sigdigits = 6) == round.(refdict3[:AUClast], sigdigits = 6)
# AUMClast / AUMCtau
@test round.(dsnca[:, :AUMCtau], sigdigits = 6) == round.(refdict3[:AUMCtau], sigdigits = 6)
# AUCall
@test round.(dsnca[:, :AUCall], sigdigits = 6) == round.(refdict3[:AUCall], sigdigits = 6)
# Rsq
# Adjusted Rsq
# LZint
@test round.(dsnca[:, :LZint], sigdigits = 6) == round.(refdict3[:LZint], sigdigits = 6)
# Kel
@test round.(dsnca[:, :Kel], sigdigits = 6) == round.(refdict3[:Kel], sigdigits = 6)
# HL
@test round.(dsnca[:, :HL], sigdigits = 6) == round.(refdict3[:HL], sigdigits = 6)
# Clast_pred
@test round.(dsnca[:, :Clast_pred], sigdigits = 6) == round.(refdict3[:Clast_pred], sigdigits = 6)
# AUCinf
@test round.(dsnca[:, :AUCinf], sigdigits = 6) == round.(refdict3[:AUCinf], sigdigits = 6)
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
@test round.(dsnca[:, :AUCpct], sigdigits = 6) == round.(refdict3[:AUCpct], sigdigits = 6)
# MRTlast
# MRTinf / MRTtauinf
@test round.(dsnca[:, :MRTtauinf], sigdigits = 6) == round.(refdict3[:MRTtauinf], sigdigits = 6)
# MRTinf_pred
# Cllast
# Clinf / Cltau
@test round.(dsnca[:, :Cltau], sigdigits = 6) == round.(refdict3[:Cltau], sigdigits = 6)
# Vzlast
# Vzinf / Vztau
@test round.(dsnca[:, :Vztau], sigdigits = 6) == round.(refdict3[:Vztau], sigdigits = 6)
# Vssinf
# AUCtau
@test round.(dsnca[:, :AUCtau], sigdigits = 6) == round.(refdict3[:AUCtau], sigdigits = 6)
# AUClast
# AUMClast / AUMCtau
# AUCall
# Rsq
# Adjusted Rsq
# Kel
# HL
# LZint
# Clast_pred
# AUCinf
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
# MRTlast
# MRTinf / MRTtauinf
# MRTinf_pred
# Cllast
# Clinf / Cltau
# Vzlast
# Vzinf / Vztau
# Vssinf
# AUCtau
# Ctau
# Cavg
# Ctaumin
# Accind
# Fluc
# Fluctau
# Swing
# Swingtau
end
@testset " #4 Log trapezoidal ATM, Dose 120, Dosetime 0, tau 12 " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 120, time = 0, tau = 12))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :logt)
# Cmax
@test dsnca[:, :Cmax] == refdict4[:Cmax]
# Tmax
@test dsnca[:, :Tmax] == refdict4[:Tmax]
# Cdose
@test round.(dsnca[:, :Cdose], sigdigits = 4) == round.(refdict4[:Cdose], sigdigits = 4)
# Tlag
# Clast
@test dsnca[:, :Clast] == refdict4[:Clast]
# AUClast
@test round.(dsnca[:, :AUClast], digits = 4) == round.(refdict4[:AUClast], digits = 4)
# AUMClast / AUMCtau
@test round.(dsnca[:, :AUMCtau], digits = 3) == round.(refdict4[:AUMCtau], digits = 3)
# AUCall
@test round.(dsnca[:, :AUCall], digits = 4) == round.(refdict4[:AUCall], digits = 4)
# Rsq
# Adjusted Rsq
# LZint
@test round.(dsnca[:, :LZint], digits = 6) == round.(refdict4[:LZint], digits = 6)
# Kel
@test round.(dsnca[:, :Kel], digits = 6) == round.(refdict4[:Kel], digits = 6)
# HL
@test round.(dsnca[:, :HL], digits = 3) == round.(refdict4[:HL], digits = 3)
# Clast_pred
@test round.(dsnca[:, :Clast_pred], digits = 4) == round.(refdict4[:Clast_pred], digits = 4)
# AUCinf
@test round.(dsnca[:, :AUCinf], digits = 3) == round.(refdict4[:AUCinf], digits = 3)
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
@test round.(dsnca[:, :AUCpct], digits = 4) == round.(refdict4[:AUCpct], digits = 4)
# MRTlast
# MRTinf / MRTtauinf
@test round.(dsnca[:, :MRTtauinf], digits = 4) == round.(refdict4[:MRTtauinf], digits = 4)
# MRTinf_pred
# Cllast
# Clinf / Cltau
@test round.(dsnca[:, :Cltau], digits = 6) == round.(refdict4[:Cltau], digits = 6)
# Vzlast
# Vzinf / Vztau
@test round.(dsnca[:, :Vztau], digits = 6) == round.(refdict4[:Vztau], digits = 6)
# Vssinf
# AUCtau
@test round.(dsnca[:, :AUCtau], digits = 4) == round.(refdict4[:AUCtau], digits = 4)
#=
@test dsnca[:, :Cmax] == [190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482]
# Tmax
@test dsnca[:, :Tmax] == [1
1
1.5
1
4
2.5
2.5
4
3
2]
# Cdose
@test round.(dsnca[:, :Cdose], sigdigits = 6) == round.([0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0], sigdigits = 6)
# Tlag
#=
@test round.(dsnca[:, :Tlag], sigdigits = 6) == round.([0
0
0
0
0.5
0
0
0
0
0], sigdigits = 6)
=#
# Clast
@test dsnca[:, :Clast] == [112.846
85.241
67.901
97.625
110.778
69.501
58.051
74.437
93.44
42.191]
# AUClast
@test round.(dsnca[:, :AUClast], sigdigits = 6) == round.([9572.8582
10054.0370
5391.5322
9296.2179
9518.6531
6948.5757
6987.0645
7064.7816
8298.9634
5485.6538], sigdigits = 6)
=#
end
@testset " Linear up Log down ATM, Dose 120, Dosetime 0, tau 12 " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 120, time = 0, tau = 12))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luldt)
@test MetidaNCA.cmax(MetidaNCA.gettime(ds[1]), MetidaNCA.getobs(ds[1])) == 190.869
@test MetidaNCA.tmax(MetidaNCA.gettime(ds[1]), MetidaNCA.getobs(ds[1])) == 1
@test round(MetidaNCA.auc(MetidaNCA.gettime(ds[1]), MetidaNCA.getobs(ds[1]), calcm = :luldt), sigdigits = 8) == round(9573.810558691312, sigdigits = 8)
# Cmax
@test dsnca[:, :Cmax] == [190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482]
# Tmax
@test dsnca[:, :Tmax] == [1
1
1.5
1
4
2.5
2.5
4
3
2]
# Cdose
@test round.(dsnca[:, :Cdose], sigdigits = 6) == round.([0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0], sigdigits = 6)
# Tlag
@test round.(dsnca[:, :Tlag], sigdigits = 6) == round.([0
0
0
0
0.5
0
0
0
0
0], sigdigits = 6)
# Clast
@test dsnca[:, :Clast] == [112.846
85.241
67.901
97.625
110.778
69.501
58.051
74.437
93.44
42.191]
@test round.(dsnca[:, :AUClast], sigdigits = 6) == round.([9573.810558691312
10054.286478059563
5392.457219413793
9297.096334450325
9519.181808199797
6948.985621117448
6988.960344867885
7073.306755718137
8303.373085532965
5486.838889441992], sigdigits = 6)
@test round.(dsnca[:, :AUCinf], sigdigits = 6) == round.([42913.407881300096
16097.04111262767
26022.090028134975
21983.33845321829
25778.19670343543
15984.14736468632
11648.33951823218
15408.84256127436
24853.53879891218
7941.268553852982], sigdigits = 6)
end
@testset " Linear up Log down, Dose 120, Dosetime 0, tau 12 " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 120, time = 0, tau = 12))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld)
# Cmax
@test dsnca[:, :Cmax] == [190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482]
# Tmax
@test dsnca[:, :Tmax] == [1
1
1.5
1
4
2.5
2.5
4
3
2]
# Cdose
@test round.(dsnca[:, :Cdose], sigdigits = 6) == round.([0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0
0.0], sigdigits = 6)
# Tlag
#=
@test round.(dsnca[:, :Tlag], sigdigits = 6) == round.([0
0
0
0
0.5
0
0
0
0
0], sigdigits = 6)
=#
# Clast
@test dsnca[:, :Clast] == [112.846
85.241
67.901
97.625
110.778
69.501
58.051
74.437
93.44
42.191]
# AUClast
@test round.(dsnca[:, :AUClast], sigdigits = 6) == round.([9573.8106
10054.286
5392.4572
9297.0963
9519.1809
6948.9856
6988.7726
7073.0922
8303.3586
5486.8389], sigdigits = 6)
# AUMCtau
@test round.(dsnca[:, :AUMCtau], sigdigits = 6) == round.([9995.4521
14645.001
6030.6644
10314.429
11475.22
8486.2318
9023.7903
6403.6719
10120.542
8376.0054], sigdigits = 6)
# AUCall
@test round.(dsnca[:, :AUCall], sigdigits = 6) == round.([9573.8106
10054.286
5392.4572
9297.0963
9519.1809
6948.9856
6988.7726
7073.0922
8303.3586
5486.8389
], sigdigits = 6)
# Rsq
@test round.(dsnca[:, :Rsq], digits = 6) == round.([0.78607696
0.99276359
0.81358898
0.91885869
0.85335995
0.95011904
0.97031231
0.94796904
0.94753789
0.88092269], digits = 6)
# Adjusted Rsq
@test round.(dsnca[:, :ARsq], digits = 6) == round.([0.71476928
0.99035145
0.77630678
0.83771737
0.82891994
0.92517856
0.96041642
0.92195356
0.92130684
0.86391165], digits = 6)
# Kel
@test round.(dsnca[:, :Kel], sigdigits = 6) == round.([0.0033847439
0.014106315
0.0032914304
0.0076953442
0.0068133279
0.0076922807
0.012458956
0.0089300798
0.0056458649
0.017189737], sigdigits = 6)
# HL
@test round.(dsnca[:, :HL], sigdigits = 5) == round.([204.78571
49.137367
210.59148
90.073577
101.73401
90.10945
55.634451
77.619371
122.77077
40.323315], sigdigits = 5)
# Clast_pred
@test round.(dsnca[:, :Clast_pred], sigdigits = 6) == round.([117.30578
82.53669
66.931057
100.76793
105.29832
71.939942
61.172702
75.604277
93.761762
38.810857], sigdigits = 6)
# AUCinf
@test round.(dsnca[:, :AUCinf], sigdigits = 6) == round.([42913.408
16097.041
26022.09
21983.338
25778.196
15984.147
11648.152
15408.628
24853.524
7941.2686], sigdigits = 6)
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
@test round.(dsnca[:, :AUCpct], sigdigits = 5) == round.([77.690398
37.539537
79.277386
57.708442
63.072742
56.525766
40.001017
54.096548
66.59082
30.907274], sigdigits = 5)
# MRTlast
#=
@test round.(dsnca[:, :MRTlast], digits = 6) == round.([34.801023
29.538786
34.472406
33.69408
32.964438
32.58076
31.267574
33.826053
33.386807
27.556657], digits = 6)
=#
# MRTtauinf
@test round.(dsnca[:, :MRTtauinf], digits = 4) == round.([302.522490
75.321653
312.895820
148.293830
172.561490
130.198390
91.786365
163.779880
176.558310
68.172066], digits = 4 )
# MRTinf_pred
# Cllast
# Cltau
@test round.(dsnca[:, :Cltau], sigdigits = 6) == round.([0.071896833
0.050424060
0.122488280
0.070172356
0.069035042
0.085192949
0.083697775
0.110260280
0.073377834
0.092799594], sigdigits = 6)
# Vzlast
# Vztau
@test round.(dsnca[:, :Vztau], sigdigits = 6) == round.([21.241439
3.574574
37.214301
9.118807
10.132353
11.075122
6.717880
12.347065
12.996739
5.398547], sigdigits = 6)
# Vssinf
end
@testset " Linear trapezoidal, Dose 100, Dosetime 2.0, tau 10 " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 2.0, tau = 10))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :lint)
# Cmax
@test dsnca[:, :Cmax] == [150.854
234.091
100.943
165.177
169.334
154.648
153.254
138.327
167.347
125.482]
# Tmax
@test dsnca[:, :Tmax] == [4
2
2
2
4
2.5
2.5
4
3
2]
# Cdose
# Tlag
# Clast
# AUClast
@test round.(dsnca[:, :AUClast], digits = 3) == round.([9283.0588
9774.9218
5255.0335
9051.5985
9441.4205
6781.2608
6858.7153
6885.9150
8094.8320
5495.0990], digits = 3)
# AUMClast / AUMCtau
@test round.(dsnca[:, :AUMCtau], digits = 3) == round.([6915.4913
10105.3000
4166.2103
7068.4668
8032.4660
5775.6840
6243.2670
4442.4953
6999.9440
5849.5573], digits = 3)
# AUCall
# Rsq
# Adjusted Rsq
# Kel
# HL
# LZint
@test round.(dsnca[:, :LZint], sigdigits = 6) == round.([5.0084856
5.4288976
4.4406461
5.166885
5.1473571
4.8296758
5.0107459
4.9684786
4.9472594
4.8963611], sigdigits = 6)
# Clast_pred
@test round.(dsnca[:, :Clast_pred], digits = 3) == round.([117.30578
82.53669
66.931057
100.76793
105.29832
71.939942
61.172702
75.604277
93.761762
38.810857], digits = 3)
# AUCinf
@test round.(dsnca[:, :AUCinf], digits = 3) == round.([42622.6560
15817.6760
25884.6660
21737.8410
25700.4350
15816.4220
11518.0940
15221.4510
24644.9980
7949.5287], digits = 3)
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
# MRTlast
# MRTinf / MRTtauinf
@test round.(dsnca[:, :MRTtauinf], digits = 3) == round.([306.68478
72.36944
303.54748
145.34822
153.74241
123.86557
85.934338
167.95643
168.74491
63.074784], digits = 3)
# MRTinf_pred
# Cllast
# Clinf / Cltau
# Vzlast
# Vzinf / Vztau
# Vssinf
# AUCtau
@test round.(dsnca[:, :AUCtau], digits = 3) == round.([1367.7388
2043.0158
838.8295
1444.7985
1618.6205
1224.6608
1265.7013
880.311
1417.942
1167.911], digits = 3)
# Ctau
@test round.(dsnca[:, :Ctau], sigdigits = 6) == round.([144.964
196.035
76.027
132.257
154.066
113.751
123.37
134.133
135.58
106.476], sigdigits = 6)
# Cavg
@test round.(dsnca[:, :Cavg], digits = 3) == round.([136.77388
204.30158
83.88295
144.47985
161.86205
122.46608
126.57013
88.0311
141.7942
116.7911], digits = 3)
# Ctaumin
@test round.(dsnca[:, :Ctaumin], sigdigits = 6) == round.([121.239
196.026
69.985
128.398
151.452
102.16
105.513
22.724
105.438
106.476], sigdigits = 6)
# Accind
@test round.(dsnca[:, :Accind], digits = 3) == round.([30.047153
7.600775
30.884671
13.501282
15.182793
13.506455
8.5367345
11.705549
18.216783
6.3317425], digits = 3)
# Fluc
@test round.(dsnca[:, :Fluc], sigdigits = 6) == round.([21.652527
18.631770
36.906189
25.456145
11.047679
42.859216
37.719011
131.320640
43.661165
16.273500], sigdigits = 6)
# Swing
@test round.(dsnca[:, :Swing], sigdigits = 6) == round.([0.24426958
0.19418342
0.44235193
0.28644527
0.11807041
0.51378230
0.45246557
5.08726460
0.58716023
0.17850032], sigdigits = 6)
end
@testset " Linear trapezoidal, Dose 100, Dosetime 0.0, tau 100 " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0.0, tau = 100))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld)
# Cmax
@test dsnca[:, :Cmax] == [190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482]
# Tmax
@test dsnca[:, :Tmax] == [1
1
1.5
1
4
2.5
2.5
4
3
2]
# Cdose
# Tlag
# Clast
# AUClast
@test round.(dsnca[:, :AUClast], digits = 3) == round.([9573.810559
10054.28648
5392.457219
9297.096334
9519.180874
6948.985621
6988.772632
7073.092214
8303.358586
5486.838889], digits = 3)
# AUMClast / AUMCtau
@test round.(dsnca[:, :AUMCtau], digits = 3) == round.([599491.4507
469656.5157
341841.895
530699.316
554228.2569
381802.405
343144.4367
402118.7541
487552.4608
233710.5713], digits = 3)
# AUCall
# Rsq
# Adjusted Rsq
# Kel
# HL
# LZint
@test round.(dsnca[:, :LZint], sigdigits = 6) == round.([5.0084856
5.4288976
4.4406461
5.166885
5.1473571
4.8296758
5.0107459
4.9684786
4.9472594
4.8963611], sigdigits = 6)
# Clast_pred
@test round.(dsnca[:, :Clast_pred], digits = 3) == round.([117.30578
82.53669
66.931057
100.76793
105.29832
71.939942
61.172702
75.604277
93.761762
38.810857], digits = 3)
# AUCinf
@test round.(dsnca[:, :AUCinf], digits = 3) == round.([42913.4078813004
16097.0411126277
26022.0900281352
21983.3384532182
25778.1957695968
15984.1473646863
11648.1518057779
15408.6280190766
24853.5242997128
7941.2685538530], digits = 3)
# AUCinf_pred
# AUMCinf
# AUMCinf_pred
# AUCpct
# MRTlast
# MRTinf / MRTtauinf
@test round.(dsnca[:, :MRTtauinf], digits = 3) == round.([286.7298872
73.32812486
309.1287691
131.3893596
155.1600979
126.8510359
79.61736185
117.5547609
177.1315649
60.86551733], digits = 3)
# MRTinf_pred
# Cllast
# Clinf / Cltau
# Vzlast
# Vzinf / Vztau
# Vssinf
# AUCtau
@test round.(dsnca[:, :AUCtau], digits = 3) == round.([12646.63632
11996.6718
7195.902904
11794.11692
12274.83395
8729.151856
8395.400098
8930.999936
10727.4135
6389.420453], digits = 3)
# Ctau
@test round.(dsnca[:, :Ctau], sigdigits = 6) == round.([106.6989373
55.60460942
61.0383917
81.23535402
87.01010737
58.00027625
43.15724396
58.8781831
80.05171762
23.98401112], sigdigits = 6)
# Cavg
@test round.(dsnca[:, :Cavg], digits = 3) == round.([126.4663632
119.966718
71.95902904
117.9411692
122.7483395
87.29151856
83.95400098
89.30999936
107.274135
63.89420453], digits = 3)
# Ctaumin
@test round.(dsnca[:, :Ctaumin], sigdigits = 6) == round.([0
0
0
0
0
0
0
0
0
0], sigdigits = 6)
# Accind
@test round.(dsnca[:, :Accind], digits = 3) == round.([3.482585727
1.322732351
3.565571971
1.862990767
2.024054788
1.863483514
1.403869629
1.693257481
2.318008606
1.218397838], digits = 3)
# Fluc
@test round.(dsnca[:, :Fluc], sigdigits = 6) == round.([150.9247164
217.7078813
146.3958052
176.8186643
137.9521716
177.1626872
182.5452012
154.8841126
155.9993935
196.3902687], sigdigits = 6)
# Swing
# Swing tau
@test round.(dsnca[:, :Swingtau], sigdigits = 6) == round.([0.788855679643705
3.697038657747540
0.725880991766796
1.567133516128610
0.946141719805552
1.666332127921700
2.551060863661350
1.349376164748240
1.090486062900490
4.231902178181850], sigdigits = 6)
end
@testset " Linear up Log down, Dose 100, Dosetime 0.25, tau 9 IV " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0.25, tau = 9))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :iv, calcm = :luld)
@test dsnca[:, :Cdose] == [178.949
62.222
49.849
52.421
0.0
57.882
19.95
142.34985100539438
113.362
13.634]
end
@testset " Linear trapezoidal, Dose 120, Dosetime 0, tau 12 IV " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 120, time = 0.0, tau = 12))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :iv, calcm = :lint)
@test dsnca[:, :Cmax] == [190.869
261.177
105.345
208.542
169.334
154.648
153.254
138.327
167.347
125.482]
@test round.(dsnca[:, :Clast], sigdigits = 6) == round.([112.846
85.241
67.901
97.625
110.778
69.501
58.051
74.437
93.44
42.191], sigdigits = 6)
@test round.(dsnca[:, :Clast_pred], sigdigits = 6) == round.([117.30578
82.53669
66.931057
100.76793
105.19623
71.939942
61.172702
75.604277
93.761762
39.408841], sigdigits = 6)
@test round.(dsnca[:, :AUClast], sigdigits = 6) == round.([9585.4218
10112.176
5396.5498
9317.8358
9561.26
6966.598
7029.5735
7110.6745
8315.0803
5620.8945], sigdigits = 6)
@test round.(dsnca[:, :AUCinf], sigdigits = 6) == round.([42925.019
16154.93
26026.183
22004.078
25714.393
16001.76
11688.953
15446.21
24865.246
8171.1624], sigdigits = 6)
@test round.(dsnca[:, :Ctau], sigdigits = 6) == round.([144.964
196.035
76.027
132.257
154.066
113.751
123.37
134.133
135.58
106.476], sigdigits = 6)
@test round.(dsnca[:, :HL], sigdigits = 5) == round.([204.78571
49.137367
210.59148
90.073577
101.0715
90.10945
55.634451
77.619371
122.77077
41.897822], sigdigits = 5)
end
@testset " Linear trapezoidal, Dose 100, Dosetime 0, no tau AUCall " begin
dsnca = MetidaNCA.nca(aucallpk, :Time, :Concentration; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0), adm = :ev, calcm = :lint)
@test dsnca[:AUClast] ≈ 9585.4218
aucl = MetidaNCA.linauc(72, 96, 112.846, 0)
dsnca[:AUClast] + aucl ≈ dsnca[:AUCall]
end
@testset " Partials " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0.25, tau = 9))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld, partials = [(0.25, 9.25)])
v1 = dsnca[:, Symbol("AUC_0.25_9.25")]
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0.25, tau = 9))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld)
v2 = dsnca[:, :AUCtau]
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld, partials = [(0.25, 9.25), [0.25, 9], Pair(1, 3)], verbose = 3, io = io)
v3 = dsnca[:, Symbol("AUC_0.25_9.25")]
@test v1 ≈ v2 atol=1E-6
@test v3 ≈ [1264.305068205526
1827.9316525749111
751.5337978798051
1333.204619921286
1310.904516109241
1110.6227262325967
1078.119979444785
772.3366199961695
1213.5372385701808
969.4541441511578] atol=1E-6
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0.0, tau = 100))
sort!(ds, :Subject)
@test_throws ErrorException dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld, partials = [(0.25, 100)], prtext = :err)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld, partials = [(0, 100)], prtext = :last)
@test dsnca[:, :AUClast] ≈ dsnca[:, :AUC_0_100] atol=1E-6
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld, partials = [(0, 100)], prtext = :extr)
@test dsnca[:, :AUCtau] ≈ dsnca[:, :AUC_0_100] atol=1E-6
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld, partials = [(0, 72)], prtext = :last)
@test dsnca[:, :AUCall] ≈ dsnca[:, :AUC_0_72] atol=1E-6
end
@testset " set-get*! tests " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation])
sort!(ds, :Subject)
#=
@testset " #1 setkelauto! " begin
ka = MetidaNCA.setkelauto!(ds[1], false)
@test MetidaNCA.getkelauto(ka) == true
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luldt)
end
=#
@testset " setdosetime! " begin
dt = MetidaNCA.DoseTime(dose = 110, time = 2.1, tau = 10)
MetidaNCA.setdosetime!(ds[1], dt)
dts = MetidaNCA.getdosetime(ds[1])
@test dts.dose == 110
@test dts.time == 2.1
@test dts.tau == 10
dt2 = MetidaNCA.DoseTime(dose = 100, time = 2.2, tau = 9)
MetidaNCA.setdosetime!(ds, dt2, 4)
MetidaNCA.setdosetime!(ds, dt2, [1,2,3])
MetidaNCA.setdosetime!(ds, dt2, Dict(:Formulation => "R"))
MetidaNCA.setdosetime!(ds, dt2)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luldt)
end
@testset " #2 setkelauto! " begin
kr = MetidaNCA.ElimRange(kelstart = 4, kelend = 12)
MetidaNCA.setkelrange!(ds, kr; kelauto = true)
MetidaNCA.setkelauto!(ds, false, 4)
MetidaNCA.setkelauto!(ds, false, [1,2,3])
MetidaNCA.setkelauto!(ds, false, Dict(:Formulation => "R"))
MetidaNCA.setkelauto!(ds, false)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luldt)
@test MetidaNCA.getkelauto(ds[1]) == false
end
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation])
sort!(ds, :Subject)
@testset " setkelrange! " begin
dsnca1 = deepcopy(MetidaNCA.nca!(ds[1], adm = :ev, calcm = :luldt))
kr = MetidaNCA.ElimRange(kelstart = 12, kelend = 16)
MetidaNCA.setkelrange!(ds[1], kr)
dsnca2 = deepcopy(MetidaNCA.nca!(ds[1], adm = :ev, calcm = :luldt))
@test dsnca1.data.keldata.ar[3] ≈ 0.7147692761075757
@test dsnca1.data.keldata.ar[3] ≈ dsnca2.data.keldata.ar[1]
@test dsnca1.data.keldata.a[3] ≈ dsnca2.data.keldata.a[1]
@test dsnca1.data.keldata.b[3] ≈ dsnca2.data.keldata.b[1]
kr = MetidaNCA.ElimRange(kelstart = 12, kelend = 16, kelexcl = Int[5,6])
MetidaNCA.setkelrange!(ds[1], kr)
dsnca3 = deepcopy(MetidaNCA.nca!(ds[1], adm = :ev, calcm = :luldt))
@test dsnca1.data.keldata.ar[3] ≈ dsnca3.data.keldata.ar[1]
@test dsnca1.data.keldata.a[3] ≈ dsnca3.data.keldata.a[1]
@test dsnca1.data.keldata.b[3] ≈ dsnca3.data.keldata.b[1]
kr = MetidaNCA.ElimRange(kelexcl = Int[5,6])
MetidaNCA.setkelrange!(ds[1], kr; kelauto = true)
dsnca4 = deepcopy(MetidaNCA.nca!(ds[1], adm = :ev, calcm = :luldt))
@test dsnca1.data.keldata.ar[3] ≈ dsnca4.data.keldata.ar[3]
@test dsnca1.data.keldata.a[3] ≈ dsnca4.data.keldata.a[3]
@test dsnca1.data.keldata.b[3] ≈ dsnca4.data.keldata.b[3]
kr = MetidaNCA.ElimRange(kelstart = 4, kelend = 12, kelexcl = Int[5,6])
MetidaNCA.setkelrange!(ds[1], kr)
krs = MetidaNCA.getkelrange(ds[1])
@test krs.kelstart == 4
@test krs.kelend == 12
@test krs.kelexcl == [5,6]
kr2 = MetidaNCA.ElimRange(kelstart = 3, kelend = 12, kelexcl = Int[7])
MetidaNCA.setkelrange!(ds, kr2, 4)
MetidaNCA.setkelrange!(ds, kr2, [1,2,3])
MetidaNCA.setkelrange!(ds, kr2, Dict(:Formulation => "R"))
MetidaNCA.setkelrange!(ds, kr2)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luldt)
end
end
@testset " applylimitrule! " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation])
sort!(ds, :Subject)
lr = MetidaNCA.LimitRule(;lloq = 0.5, btmax = 0.0, atmax = NaN, nan = NaN, rm = true)
MetidaNCA.applylimitrule!(ds[1], lr)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luldt)
lr = MetidaNCA.LimitRule(;lloq = 0.5, btmax = 0.5, atmax = NaN, nan = NaN, rm = true)
function af(sbj)
sbj.id[:Subject] == 1
end
MetidaNCA.applylimitrule!(af, ds, lr)
@test ds[1].obs[1] ≈ 0.5
MetidaNCA.applylimitrule!(ds, lr, 2)
@test ds[2].obs[1] ≈ 0.5
MetidaNCA.applylimitrule!(ds, lr, 3:4)
@test ds[3].obs[1] ≈ 0.5
@test ds[4].obs[1] ≈ 0.5
MetidaNCA.applylimitrule!(ds, lr, Dict(:Formulation => "R"))
@test ds[7].obs[1] ≈ 0.5
MetidaNCA.applylimitrule!(ds, lr)
@test ds[6].obs[1] ≈ 0.5
ds = MetidaNCA.pkimport(missingpk, :Time, :Concentration)
@test ismissing(ds.obs[13])
@test isnan(ds.obs[15])
@test length(ds) == 18
MetidaNCA.applylimitrule!(ds, lr)
@test length(ds) == 16
ds = MetidaNCA.pkimport(missingpk, :Time, :Concentration)
lr = MetidaNCA.LimitRule(;lloq = 180, btmax = 0.0, atmax = 0.5, nan = 1000, rm = false)
MetidaNCA.applylimitrule!(ds, lr)
@test ds.obs == [0.0
0.0
190.869
0.5
0.5
0.5
0.5
0.5
0.5
0.5
0.5
0.5
1000.0
0.5
1000.0
0.5
0.5
0.5]
end
@testset " kel " begin
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation])
sort!(ds, :Subject)
kr1 = MetidaNCA.ElimRange(kelstart = 4, kelend = 12, kelexcl = Int[5,6])
kr2 = MetidaNCA.ElimRange(kelstart = 3, kelend = 12, kelexcl = Int[7])
MetidaNCA.setkelrange!(ds, kr1, Dict(:Formulation => "T"))
MetidaNCA.setkelrange!(ds, kr2, Dict(:Formulation => "R"))
sub1 = MetidaNCA.subset(ds, Dict(:Formulation => "T"))
@test MetidaNCA.getkelrange(sub1[1]) == kr1
sub2 = MetidaNCA.subset(ds, Dict(:Formulation => "R"))
@test MetidaNCA.getkelrange(sub2[1]) == kr2
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luldt)
end
@testset " Output " begin
io = IOBuffer();
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
sort!(ds, :Subject)
@test_nowarn dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :lint, verbose = 1, io = io)
show(io, ds[1])
dt = MetidaNCA.DoseTime(dose = 100, time = 0.25, tau = 9)
MetidaNCA.setdosetime!(ds, dt)
@test_nowarn dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld, verbose = 1, io = io)
show(io, ds[1])
kr = MetidaNCA.ElimRange(kelstart = 10, kelend = 16, kelexcl = Int[13,14])
MetidaNCA.setkelrange!(ds, kr; kelauto = false)
show(io, ds[1])
@test_nowarn dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :lint, verbose = 2, io = io)
# UPK
io = IOBuffer();
upkds = MetidaNCA.upkimport(upkdata, :st, :et, :conc, :vol, :subj; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
@test_nowarn show(io, upkds[1])
@test_nowarn dsnca = MetidaNCA.nca!(upkds, verbose = 2, io = io)
upkds = MetidaNCA.upkimport(upkdata, :st, :et, :conc, :vol; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
upkds = MetidaNCA.upkimport(upkdata[!, :st], upkdata[!, :et], upkdata[!, :conc], upkdata[!, :vol]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
unca = MetidaNCA.nca!(upkds)
@test_nowarn show(io, upkds)
@test_nowarn show(io, unca)
@test_nowarn MetidaNCA.nca(upkdata, :st, :et, :conc, :vol; type = :ur, dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
# PD
io = IOBuffer();
pd = MetidaNCA.pdimport(pddata, :time, :obs, :subj; bl = 1.5, th = 5.0)
pd_res = MetidaNCA.nca!(pd[1], verbose = 2, io = io)
pd_rds = MetidaNCA.nca!(pd, verbose = 2, io = io)
pd_rds = MetidaNCA.nca!(pd; calcm = :luld, verbose = 2, io = io)
pd_rds = MetidaNCA.nca!(pd; calcm = :logt, verbose = 2, io = io)
pd_rds = MetidaNCA.nca!(pd; calcm = :luldt, verbose = 2, io = io)
@test_nowarn show(io, pd[1])
@test_nowarn show(io, pd)
@test_nowarn show(io, pd_res)
@test_nowarn show(io, pd_rds)
end
@testset " timefilter " begin
io = IOBuffer();
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation])
ds2 = MetidaNCA.timefilter(ds, (0.75, 24))
@test minimum(ds2[1].time) >= 0.75
@test maximum(ds2[1].time) <= 24
ds2 = MetidaNCA.timefilter(ds, LinRange(0.75, 24, 2))
@test minimum(ds2[1].time) >= 0.75
@test maximum(ds2[1].time) <= 24
end
@testset " Sparse PK " begin
obs = [0.2
0.3
0.4
0.3
0.2
0.1]
time = [1
2
3
4
5
6]
auc = MetidaNCA.auc_sparse(time, obs)
@test auc ≈ 1.35 atol=1E-5
@test_throws ErrorException MetidaNCA.auc_sparse([1], [1])
@test_throws ErrorException MetidaNCA.auc_sparse([1,2], [1,2,3])
@test_throws ErrorException MetidaNCA.auc_sparse([2,1], [1,2])
end
include("upktest.jl")
include("pdtest.jl")
#Unitful
@testset " Unitful " begin
io = IOBuffer();
upk = deepcopy(pkdata2)
upk.Time = upk.Time .* u"hr"
upk.Concentration = upk.Concentration .* u"ng/ml"
uds = MetidaNCA.pkimport(upk, :Time, :Concentration, [:Subject, :Formulation])
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation])
upknca = MetidaNCA.nca!(uds, calcm = :lint)
pknca = MetidaNCA.nca!(ds, calcm = :lint)
@test upknca[:, :AUClast] ≈ pknca[:, :AUClast] .* u"ng*hr/ml"
@test upknca[:, :Kel] ≈ pknca[:, :Kel] .* u"1/hr"
upknca = MetidaNCA.nca!(uds, calcm = :luldt)
pknca = MetidaNCA.nca!(ds, calcm = :luldt)
udt = MetidaNCA.DoseTime(dose = 100u"mg", time = 0.25u"hr", tau = 9u"hr")
dt = MetidaNCA.DoseTime(dose = 100, time = 0.25, tau = 9)
MetidaNCA.setdosetime!(uds, udt)
MetidaNCA.setdosetime!(ds, dt)
upknca = MetidaNCA.nca!(uds, calcm = :lint)
pknca = MetidaNCA.nca!(ds, calcm = :lint)
upknca = MetidaNCA.nca!(uds, calcm = :luldt)
pknca = MetidaNCA.nca!(ds, calcm = :luldt)
@test upknca[:, :AUCtau] ≈ pknca[:, :AUCtau] .* u"ng*hr/ml"
@test upknca[:, :MRTtauinf] ≈ pknca[:, :MRTtauinf] .* u"hr"
upk = deepcopy(upkdata)
upk.st = upk.st .* u"hr"
upk.et = upk.et .* u"hr"
upk.conc = upk.conc .* u"ng/ml"
upk.vol = upk.vol .* u"l"
uds = MetidaNCA.upkimport(upk, :st, :et, :conc, :vol, :subj; dosetime = MetidaNCA.DoseTime(dose = 100u"mg", time = 0u"hr"))
@test_nowarn pknca = MetidaNCA.nca!(uds)
upd = deepcopy(pddata)
upd.time = upd.time .* u"hr"
upd.obs = upd.obs .* u"m"
pd = MetidaNCA.pdimport(upd, :time, :obs; bl = 3.0, th = 1.5, id = Dict(:subj => 1))
@test_nowarn pd_rds = MetidaNCA.nca!(pd);
#pd_rds = MetidaNCA.nca!(pd, io = io, verbose = 2)
end
@testset " Precompile " begin
data = MetidaNCA.metida_table([0.,1.,2.,3.,4.,2.,1.,0.], [0.,1.,2.,3.,4.,5.,6.,7.], names = (:conc, :time))
pki = MetidaNCA.pkimport(data, :time, :conc; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0, tau = 5.5))
@test_nowarn MetidaNCA.nca!(pki)
end
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | code | 1134 |
@testset " #5 Urine data; Linear-trapezoidal rule " begin
upkds = MetidaNCA.upkimport(upkdata, :st, :et, :conc, :vol, :subj; dosetime = MetidaNCA.DoseTime(dose = 100.0, time = 0))
unca = MetidaNCA.nca!(upkds)
for k in keys(urefdict)
@test unca[1, k] ≈ urefdict[k] atol=1E-4
end
@test_nowarn show(io, upkds)
@test_nowarn show(io, unca)
upkdatac = deepcopy(upkdata)
upkdatac.st = float.(upkdatac.st)
upkdatac[1, :st] = NaN
@test_throws ErrorException MetidaNCA.upkimport(upkdatac, :st, :et, :conc, :vol, :subj; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
upkdatac = deepcopy(upkdata)
upkdatac.et = float.(upkdatac.et)
upkdatac[1, :et] = NaN
@test_throws ErrorException MetidaNCA.upkimport(upkdatac, :st, :et, :conc, :vol, :subj; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
upkdatac = deepcopy(upkdata)
upkdatac.et = float.(upkdatac.et)
upkdatac[1, :et] = 1.5
@test_throws ErrorException MetidaNCA.upkimport(upkdatac, :st, :et, :conc, :vol, :subj; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
end
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | docs | 2700 | # MetidaNCA
This program comes with absolutely no warranty. No liability is accepted for any loss and risk to public health resulting from use of this software.
| Version | Cover | Build | Docs |
|---------|-------|-------|------|
|[](https://juliahub.com/ui/Packages/MetidaNCA/p2tSH)|[](https://codecov.io/gh/PharmCat/MetidaNCA.jl)| | [](https://pharmcat.github.io/MetidaNCA.jl/dev/) [](https://pharmcat.github.io/MetidaNCA.jl/stable/)|
Non-compartment PK analysis (NCA).
Pharmacokinetics, sometimes abbreviated as PK, is a branch of pharmacology dedicated to determine the fate of substances administered to a living organism.
When analyzing pharmacokinetic data, one generally employs either model fitting using nonlinear regression analysis or non-compartmental analysis techniques (NCA). The method one actually employs depends on what is required from the analysis. If the primary requirement is to determine the degree of exposure following administration of a drug (such as AUC), and perhaps the drug's associated pharmacokinetic parameters, such as clearance, elimination half-life, T (max), C (max), etc., then NCA is generally the preferred methodology to use in that it requires fewer assumptions than model-based approaches.[*]
PK urine parameters and PD parameters such as Time Above/Below Baseline/Threshold can be also calculated.
Also this package include recipes for plotting PK/PD data.
* Gabrielsson J, Weiner D. Non-compartmental analysis. Methods Mol Biol. 2012;929:377-89. doi: 10.1007/978-1-62703-050-2_16. PMID: 23007438.
## Installation
```julia
import Pkg; Pkg.add("MetidaNCA")
```
## Test
```julia
Pkg.test("MetidaNCA")
```
## First step
```julia
using DataFrames, CSV, MetidaNCA
pkdata2 = CSV.File(joinpath(dirname(pathof(MetidaNCA)), "..", "test", "csv", "pkdata2.csv")) |> DataFrame
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
sort!(ds, :Subject)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :lint, verbose = 2)
```
## Plots
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | docs | 14370 |
---
title: MetidaNCA validation report
author: Vladimir Arnautov
date: `j import Dates; Dates.Date(Dates.now())`
---
```julia; echo = false
using Dates, DataFrames, CSV, PrettyTables, Latexify
```
# Introduction and package description
This is Non-compartment anlysis software. The package is designed for batch processing of pharmacokinetic data.
See documentation:
* Dev: [https://pharmcat.github.io/MetidaNCA.jl/dev/](https://pharmcat.github.io/MetidaNCA.jl/dev/)
* Stable: [https://pharmcat.github.io/MetidaNCA.jl/stable/](https://pharmcat.github.io/MetidaNCA.jl/stable/)
## Validation purpose
The main validation purpose is confirmation by examination and provision of objective evidence that software
specifications conform to user needs and intended uses, and that the particular requirements
implemented through software can be consistently fulfilled.
## Requirements
* Julia 1.6 (or higher) installed for Operating System/OS Version/Architecture in Tier 1 list
*Tier 1: Julia is guaranteed to build from source and pass all tests on these platforms when built with the default options.
Official binaries are always available and CI is run on every commit to ensure support is actively maintained.*
## Developer software life cycle
* Development stage
* Testing procedures development
* Performing testing procedures on local machine
* Push to development branch
* Make pull request to main branch
* Performing testing procedures with GitHub Actions
* Make pull request to the official registry of general Julia packages (if nessesary)
* Make release (if previous completed)
### Versions
* X.Y.Z - patch release (no breaking changes)
* X.Y.0 - minor release (may include breaking changes if X = 0)
* X.0.0 - major release (breaking changes, changes in public API)
* 0.#.# - no stable public API
* 1.#.# or higher - stable public API
## Build support
### Tier 1
* julia-version: 1.6, 1.7, 1.8
* julia-arch: x64
* os: ubuntu-latest, macOS-latest, windows-latest
\pagebreak
# Installation
## System information
* Julia version: `j Sys.VERSION`
* Current machine: `j Sys.MACHINE`
## Installation method
MetidaNCA.jl can be installed by executing the following command in REPL:
```julia; eval = false
import Pkg; Pkg.add("MetidaNCA")
```
## Version check
The installation process is checking within each testing job via GitHub Actions.
Also GitHub Action [chek](https://github.com/JuliaRegistries/General/blob/master/.github/workflows/automerge.yml)
performed before merging into JuliaRegistries/General repository
(see [Automatic merging of pull requests](https://github.com/JuliaRegistries/General#automatic-merging-of-pull-requests)).
```julia; echo = false; results = "hidden"
using MetidaNCA, Pkg
pkgversion(m::Module) = Pkg.TOML.parsefile(joinpath(dirname(string(first(methods(m.eval)).file)), "..", "Project.toml"))["version"]
ver = pkgversion(MetidaNCA)
```
Current package version:
```julia; echo = false; results = "tex"
ver
```
# Operation qualification
This part of validation based on testing procedures entails running software products under known conditions with defined inputs and
documented outcomes that can be compared to their predefined expectations. All documented public API included in testing procedures and part of
critical internal methods. Testing procedures can be found in `test` directory.
## Coverage
Code coverage report available on [Codecov.io](https://app.codecov.io/gh/PharmCat/MetidaNCA.jl).
Test procedures include all public API methods check.
* Coverage goal: >= 90.0%
## Data
Validation data available in the repository and included in the package. See Appendix 1.
## Testing results
```julia
Pkg.test("MetidaNCA")
```
\pagebreak
# Performance qualification
Purpose of this testing procedures to demonstrate performance for some critical tasks.
Results from MetidaNCA compared with Phoenix WinNonlin 8.0 results, see Appendix 2.
## Parameter's names description
```julia; echo = false, results = "tex"
dfn = DataFrame(
["Cmax" "Maximum concentration"
"Tmax" "Time at Cmax"
"Cdose" "Concentration at dose time"
"Clast" "Last non-zero concentration"
"AUClast" "AUC to Clast"
"AUMClast" "AUMC to Clast"
"AUCall" "AUC with all values"
"Rsq" "r square"
"ARsq" "Adjusted r square"
"Kel" "Terminal elimination constant"
"HL" "Half live or T1/2"
"LZint" "Intercept"
"Clast_pred" "Predicted Clast"
"AUCinf" "AUC extrapolated to infinity"
"AUCpct" "Percentage AUClast from AUCinf"
"MRTlast" "Mean Residence Time (last)"
"MRTinf" "Mean Residence Time (inf)"
"Clinf" "Clearence"
"Vzinf" "Volume of distribution"
"AUCtau" "AUC in Tau range"
"AUMCtau" "AUMC in Tau range"
"MRTtauinf" "MRT based on Tau"
"Cltau" "Clearence in Tau range"
"Vztau" "Volume of distribution in Tau range"], ["Name", "Description"])
pkdata2 = CSV.File(joinpath(dirname(pathof(MetidaNCA)), "..", "test", "csv", "pkdata2.csv")) |> DataFrame
upkdata = CSV.File(joinpath(dirname(pathof(MetidaNCA)), "..", "test", "csv", "upkdata.csv")) |> DataFrame
pddata = CSV.File(joinpath(dirname(pathof(MetidaNCA)), "..", "test", "csv", "pddata.csv")) |> DataFrame
ds = MetidaNCA.pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation];
dosetime = MetidaNCA.DoseTime(dose = 100, time = 0))
sort!(ds, :Subject)
#pretty_table(dfn; tf = tf_ascii_rounded)
show(latexify(dfn; latex=false))
```
Table: Parameter description
\pagebreak
## Output example
**Import data:**
```julia; eval = false
pkdata2 = CSV.File(
joinpath(dirname(pathof(MetidaNCA)), "..", "test", "csv", "pkdata2.csv")
) |> DataFrame
ds = pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation];
dosetime = DoseTime(dose = 100, time = 0))
sort!(ds, :Subject)
```
**Execute NCA:**
```julia; echo = true; wrap = false; line_width = 75
MetidaNCA.nca!(ds[1], adm = :ev, calcm = :lint, verbose = 1)
```
\pagebreak
## Results
### Linear-trapezoidal rule; Extravascular; Dosetime 0.0; No Tau; Dose 100
**Code:**
```julia; eval = false
nca!(ds, adm = :ev, calcm = :lint)
```
```julia; echo = false, results = "tex"
include("refdict.jl")
header = ["Parameter", "Subject", "Value", "Reference", "Difference"]
list = [:Cmax
:Tmax
:Cdose
:Clast
:AUClast
:AUMClast
:AUCall
:Rsq
:ARsq
:Kel
:HL
:Clast_pred
:AUCinf
:AUCpct
:MRTlast
:MRTinf
:Clinf
:Vzinf]
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :lint)
subjects = MetidaNCA.getid(dsnca, :, :Subject)
dft = DataFrame("Parameter"=>[], "Subject"=>[], "Value"=>[], "Reference"=>[], "Difference"=>[])
for l in list
vals = round.(dsnca[:, l], sigdigits = 6)
refs = round.(refdict[l], sigdigits = 6)
mx = hcat(fill(l, length(vals)), subjects, vals, refs, vals .- refs)
df = DataFrame(mx, header)
df.Subject = string.(Int.(df.Subject))
append!(dft, df)
end
show(latexify(dft))
```
Table: Plasma data results, Linear-trapezoidal rule, Extravascular
\pagebreak
### Linear-Up Log-Down; Extravascular; Dosetime 0.25; Tau 9; Dose 100
**Code:**
```julia; eval = false
setdosetime!(ds, DoseTime(dose = 100, time = 0.25, tau = 9))
nca!(ds, adm = :ev, calcm = :luld)
```
```julia; echo = false, results = "tex"
list = [:Cmax
:Tmax
:Cdose
:Clast
:AUClast
:AUCtau
:AUMCtau
:AUCall
:Rsq
:ARsq
:Kel
:HL
:Clast_pred
:AUCinf
:AUCpct
:MRTtauinf
:Cltau
:Vztau]
dt = MetidaNCA.DoseTime(dose = 100, time = 0.25, tau = 9)
MetidaNCA.setdosetime!(ds, dt)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :luld)
subjects = MetidaNCA.getid(dsnca, :, :Subject)
dft = DataFrame("Parameter"=>[], "Subject"=>[], "Value"=>[], "Reference"=>[], "Difference"=>[])
for l in list
vals = round.(dsnca[:, l], sigdigits = 6)
refs = round.(refdict2[l], sigdigits = 6)
mx = hcat(fill(l, length(vals)), subjects, vals, refs, vals .- refs)
df = DataFrame(mx, header)
df.Subject = string.(Int.(df.Subject))
append!(dft, df)
end
show(latexify(dft))
```
Table: Plasma data results, Linear-Up Log-Down, Extravascular
\pagebreak
### Linear-trapezoidal rule; Intravascular; Dosetime 0.0; Tau 12; Dose 120
**Code:**
```julia; eval = false
setdosetime!(ds, DoseTime(dose = 120, time = 0.0, tau = 12))
nca!(ds, adm = :iv, calcm = :lint)
```
```julia; echo = false, results = "tex"
list = [:Cmax
:Tmax
:Cdose
:Clast
:AUClast
:AUCtau
:AUMCtau
:AUCall
:Rsq
:ARsq
:Kel
:HL
:Clast_pred
:AUCinf
:AUCpct
:MRTtauinf
:Cltau
:Vztau]
dt = MetidaNCA.DoseTime(dose = 120, time = 0.0, tau = 12)
MetidaNCA.setdosetime!(ds, dt)
dsnca = MetidaNCA.nca!(ds, adm = :iv, calcm = :lint)
subjects = MetidaNCA.getid(dsnca, :, :Subject)
dft = DataFrame("Parameter"=>[], "Subject"=>[], "Value"=>[], "Reference"=>[], "Difference"=>[])
for l in list
vals = round.(dsnca[:, l], sigdigits = 6)
refs = round.(refdict3[l], sigdigits = 6)
mx = hcat(fill(l, length(vals)), subjects, vals, refs, vals .- refs)
df = DataFrame(mx, header)
df.Subject = string.(Int.(df.Subject))
append!(dft, df)
end
show(latexify(dft))
```
Table: Plasma data results, Linear-trapezoidal rule, Intravascular
\pagebreak
### Linear/Log Trapezoidal rule; Extravascular; Dosetime 0.0; Tau 12; Dose 120
**Code:**
```julia; eval = false
setdosetime!(ds, DoseTime(dose = 120, time = 0.0, tau = 12))
nca!(ds, adm = :ev, calcm = :logt)
```
```julia; echo = false, results = "tex"
list = [:Cmax
:Tmax
:Cdose
:Clast
:AUClast
:AUCtau
:AUMCtau
:AUCall
:Rsq
:ARsq
:Kel
:HL
:Clast_pred
:AUCinf
:AUCpct
:MRTtauinf
:Cltau
:Vztau]
dt = MetidaNCA.DoseTime(dose = 120, time = 0.0, tau = 12)
MetidaNCA.setdosetime!(ds, dt)
dsnca = MetidaNCA.nca!(ds, adm = :ev, calcm = :logt)
subjects = MetidaNCA.getid(dsnca, :, :Subject)
dft = DataFrame("Parameter"=>[], "Subject"=>[], "Value"=>[], "Reference"=>[], "Difference"=>[])
for l in list
vals = round.(dsnca[:, l], sigdigits = 6)
refs = round.(refdict4[l], sigdigits = 6)
mx = hcat(fill(l, length(vals)), subjects, vals, refs, vals .- refs)
df = DataFrame(mx, header)
df.Subject = string.(Int.(df.Subject))
append!(dft, df)
end
show(latexify(dft))
```
Table: Plasma data results, Linear/Log Trapezoidal rule, Extravascular
\pagebreak
### Urine data; Linear-trapezoidal rule; Extravascular; Dosetime 0.0; Dose 100
**Code:**
```julia; eval = false
upkds = upkimport(upkdata, :st, :et, :conc, :vol, :subj;
dosetime = MetidaNCA.DoseTime(dose = 100))
MetidaNCA.nca!(upkds)
```
```julia; echo = false, results = "tex"
list = collect(keys(urefdict))
upkds = MetidaNCA.upkimport(upkdata, :st, :et, :conc, :vol, :subj;
dosetime = MetidaNCA.DoseTime(dose = 100))
dsnca = MetidaNCA.nca!(upkds)
pname = string.(list)
vals = zeros(Float64, length(list))
refs = zeros(Float64, length(list))
for i = 1: length(list)
vals[i] = round(dsnca[1, list[i]], sigdigits = 6)
refs[i] = round(urefdict[list[i]], sigdigits = 6)
end
mx = hcat(pname, vals, refs, vals .- refs)
df = DataFrame(mx, ["Parameter", "Value", "Reference", "Difference"])
show(latexify(df))
```
Table: Urine data results
\pagebreak
### Pharmacodynamics data; Linear-trapezoidal rule
**Code:**
```julia; eval = false
pd = MetidaNCA.pdimport(pddata, :time, :obs;
bl = 3.0, th = 1.5, id = Dict(:subj => 1))
pdres = MetidaNCA.nca!(pd)
```
```julia; echo = false, results = "tex"
list = collect(keys(pdrefdict))
pd = MetidaNCA.pdimport(pddata, :time, :obs;
bl = 3.0, th = 1.5, id = Dict(:subj => 1))
pdres = MetidaNCA.nca!(pd)
pname = string.(list)
vals = zeros(Float64, length(list))
refs = zeros(Float64, length(list))
for i = 1: length(list)
vals[i] = round(pdres[list[i]], sigdigits = 6)
refs[i] = round(pdrefdict[list[i]], sigdigits = 6)
end
mx = hcat(pname, vals, refs, vals .- refs)
df = DataFrame(mx, ["Parameter", "Value", "Reference", "Difference"])
show(latexify(df))
```
Table: Pharmacodynamics data results
\pagebreak
# Glossary
* Installation qualification (IQ) - Establishing confidence that process equipment and ancillary systems are compliant with appropriate codes and approved design intentions, and that manufacturer's recommendations are suitably considered.
* Operational qualification (OQ) Establishing confidence that process equipment and sub-systems are capable of consistently operating within established limits and tolerances.
* Product performance qualification (PQ) - Establishing confidence through appropriate testing that the finished product produced by a specified process meets all release requirements for functionality and safety.
* Repository - GitHub repository: https://github.com/PharmCat/MetidaNCA.jl
* Master branch - main branch on GitHub ([link](https://github.com/PharmCat/MetidaNCA.jl/tree/main)).
* Current machine - pc that used for validation report generating.
# Reference
* [General Principles of Software Validation; Final Guidance for Industry and FDA Staff](https://www.fda.gov/media/73141/download)
* [Guidance for Industry Process Validation: General Principles and Practices](https://www.fda.gov/files/drugs/published/Process-Validation--General-Principles-and-Practices.pdf)
* [Glossary of Computer System Software Development Terminology](https://www.fda.gov/inspections-compliance-enforcement-and-criminal-investigations/inspection-guides/glossary-computer-system-software-development-terminology-895)
\pagebreak
# Appendix 1
### Testing PK dataset.
```julia; echo = false
pretty_table(pkdata2; tf = tf_ascii_rounded, header = names(pkdata2))
```
\pagebreak
### Testing urine PK dataset.
```julia; echo = false
pretty_table(upkdata; tf = tf_ascii_rounded, header = names(upkdata))
```
\pagebreak
### Testing PD dataset.
```julia; echo = false
pretty_table(pddata; tf = tf_ascii_rounded, header = names(pddata))
```
\pagebreak
# Appendix 2
### Reference output.
Avialible at [https://github.com/PharmCat/MetidaNCA.jl/tree/main/docs/src/pdf](https://github.com/PharmCat/MetidaNCA.jl/tree/main/docs/src/pdf).
See [Appendix 2.1.pdf](https://github.com/PharmCat/MetidaNCA.jl/blob/main/docs/src/pdf/Appendix2.1.pdf),
[Appendix 2.2.pdf](https://github.com/PharmCat/MetidaNCA.jl/blob/main/docs/src/pdf/Appendix2.2.pdf),
[Appendix 2.3.pdf](https://github.com/PharmCat/MetidaNCA.jl/blob/main/docs/src/pdf/Appendix2.3.pdf),
[Appendix 2.4.pdf](https://github.com/PharmCat/MetidaNCA.jl/blob/main/docs/src/pdf/Appendix2.4.pdf),
[Appendix 2.5.pdf](https://github.com/PharmCat/MetidaNCA.jl/blob/main/docs/src/pdf/Appendix2.5.pdf).
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | docs | 1506 | # API
## Main
### nca!
```@docs
MetidaNCA.nca!
```
### nca
```@docs
MetidaNCA.nca
```
### pkimport
```@docs
MetidaNCA.pkimport
```
### upkimport
```@docs
MetidaNCA.upkimport
```
### pdimport
```@docs
MetidaNCA.pdimport
```
## Types
### DoseTime
```@docs
MetidaNCA.DoseTime
```
### ElimRange
```@docs
MetidaNCA.ElimRange
```
### LimitRule
```@docs
MetidaNCA.LimitRule
```
### MetidaNCA.PKSubject
```@docs
MetidaNCA.PKSubject
```
### MetidaNCA.NCAResult
```@docs
MetidaNCA.NCAResult
```
## Functions
### applylimitrule!
```@docs
MetidaNCA.applylimitrule!
```
### getbl
```@docs
MetidaNCA.getbl
```
### getdosetime
```@docs
MetidaNCA.getdosetime
```
### getkelauto
```@docs
MetidaNCA.getkelauto
```
### getkelrange
```@docs
MetidaNCA.getkelrange
```
### getkeldata
```@docs
MetidaNCA.getkeldata
```
### getth
```@docs
MetidaNCA.getth
```
### pkplot
```@docs
MetidaNCA.pkplot
```
### setbl!
```@docs
MetidaNCA.setbl!
```
### setdosetime!
```@docs
MetidaNCA.setdosetime!
```
### setkelauto!
```@docs
MetidaNCA.setkelauto!
```
### setkelrange!
```@docs
MetidaNCA.setkelrange!
```
### setth!
```@docs
MetidaNCA.setth!
```
### timefilter
```@docs
MetidaNCA.timefilter
```
## Atomic
### auc_sparse
```@docs
MetidaNCA.auc_sparse
```
> **Warning**
> Atomic functions: `cmax`, `tmax`, `auc` not exported, use `import MetidaNCA: cmax, tmax, auc;`.
### auc
```@docs
MetidaNCA.auc
```
### cmax
```@docs
MetidaNCA.cmax
```
### tmax
```@docs
MetidaNCA.tmax
```
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | docs | 3142 | # Details
## Using LimitRule
```julia
ll = LimitRule(;lloq = 0.1, btmax = 0.0, atmax = NaN, nan = NaN, rm = true)
```
It means that all values below `lloq` will be replaced by `btmax` before Tmax and replaced by `atmax` after Tmax; `NaN` values will be replaced by `nan`. If `rm` is `true`, all `NaN` values will be deleted.
See also: [`applylimitrule!`](@ref).
## Using DoseTime
```julia
dt = DoseTime(dose = 200.0, time = 0.0)
```
DoseTime can be appliet to each subject or dataset and can be used with [`pkimport`](@ref).
```julia
ds = pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = dt)
```
DoseTime for staedy-state PK:
```julia
dt = DoseTime(dose = 100.0, time = 0.25, tau = 9.0)
```
See also: [`setdosetime!`](@ref).
## Calculation steps for PK NCA
### Step 1
Filter all values before dose time and `NaN` or `missing` values after last measurable concentration.
If TAU set, calculate start and end timepoints for AUCtau.
### Step 2
Cmax, Tmax calculation. Interpolate `NaN` and `missing` values.
!!! note
If more than one maximum - only first observation used for define Tmax.
### Step 3
Exclude interpolated points from calculation (add to `excltime`). Elimination parameters calculation. Find last concentration > 0 and time for last concentration > 0.
!!! note
If `kelstart` or `kelend` in `excltime` then `kelauto` set to `true`.
!!! note
If `kelauto` is `true` than range of observations for elimination will start from Tmax if administration set as `iv`, and from next observation after Tmax in other cases.
### Step 4
Shift all time values by dose time.
### Step 5
Calculate dose concentration (Cdose).
!!! note
If there is no concentration for dosing time:
* If administration set as `iv` if 1st observation > than 2nd and both > 0 - Dose concentration is log-extrapolated, else set as 1st observation.
* If administration not `iv`, than if Tau used Dose concentration set as minimal concentration, in other case set as 0.
### Step 6
Calculate areas.
!!! note
If AUClast is 0, than AUClast, AUMClast and AUCall set as `NaN`, so other dependent parameters is `NaN` too.
### Step 7
Calculate steady-state parameters.
!!! note
If end of tau interval lies between two observation, than interpolation used to compute Ctau and partial AUCs; `intpm` keyword used to define interpolation method.
If end of tau interval lies after all observation, than extrapolation used to compute Ctau and partial AUCs. Extrapolation based on using elimination parameters.
## [Unitful details](@id unitful_details)
!!! warning
**Unitful.jl**
MetidaNCA can work with [Unitful.jl](https://painterqubits.github.io/Unitful.jl/stable/).
There is no guarantee that all functions will work without errors.
All validation procedures with Unitful should be done manually before use.
!!! warning
**Dose and time settings**
If you are using Unitful, check `dositime` settings: `DoseTime(dose = 100u"mg", time = 0u"hr")`.
For properly results all values should have units (including time and concentration data in data table).
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | docs | 3338 | # Examples
```@setup ncaexample
ENV["GKSwstype"] = "nul"
```
## Import
Use [`pkimport`](@ref) to import PK data from table to subject set.
```@example ncaexample
using MetidaNCA, CSV, DataFrames;
pkdata2 = CSV.File(joinpath(dirname(pathof(MetidaNCA)), "..", "test", "csv", "pkdata2.csv")) |> DataFrame
ds = pkimport(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = DoseTime(dose = 100, time = 0))
sort!(ds, :Subject)
```
## NCA
Perform NCA analysis with [`nca!`](@ref). Access to result set is similar to DataFrame or any table.
Find parameter list [here](@ref parameter_list).
```@example ncaexample
dsnca = nca!(ds, adm = :ev, calcm = :lint)
dsnca[:, :AUClast]
```
## Partial AUC
```@example ncaexample
dsnca = nca!(ds, adm = :ev, calcm = :lint, partials = [(1, 7)])
dsnca[:, :AUC_1_7]
```
## Result modification or custom parameter function
```@example ncaexample
# Define modify! function for new parameter
function newparam(data)
data.result[:AUChalf] = data.result[:AUClast] / 2
end
dsncanp = nca!(ds, modify! = newparam)
dsncanp[1][:AUChalf]
```
Function `newparam` applyed to [`NCAResult`](@ref).
## Print output
```@example ncaexample
dsnca = nca!(ds[1], adm = :ev, calcm = :lint, verbose = 2);
```
## Plotting
```@example ncaexample
using Plots
p = pkplot(ds; typesort = :Subject, pagesort = NoPageSort(), filter = Dict(:Formulation => "R"))
png(p, "plot1.png")
p = pkplot(ds; typesort = :Formulation, pagesort = NoPageSort(), legend = true)
png(p, "plot2.png")
p = pkplot(ds; elim = true, ls = true)
png(p[1][2], "plot3.png")
# If pagesort used - return pairs with `Page ID` => `Plot`
p = pkplot(ds; typesort = :Subject, pagesort = :Formulation)
png(p[1][2], "plot4.png")
```
#### Plot 1
#### Plot 2
#### Plot 3
#### Plot 4
## Set dose time
You can set dose time with [`setdosetime!`](@ref) for whole subject set or for
selected subjects.
```@example ncaexample
dt = DoseTime(dose = 200, time = 0)
setdosetime!(ds, dt, Dict(:Formulation => "R"))
dsnca = nca!(ds)
dsnca[:, :Dose]
```
## Set range for elimination
By default no exclusion or range specified. With [`setkelrange!`](@ref) elimination range and exclusion
can be specified for whole subject set or for any selected subjects.
```@example ncaexample
kr = ElimRange(kelstart = 4, kelend = 12, kelexcl = Int[5,6])
setkelrange!(ds, kr, [1,2,3])
dsnca = nca!(ds)
p = pkplot(ds[1]; elim = true)
png(p, "plot5.png")
getkeldata(ds[1])
```
#### Plot 5
## Without import
You can use [`nca`](@ref) for NCA analysis directly from tabular data.
```@example ncaexample
dsnca = nca(pkdata2, :Time, :Concentration, [:Subject, :Formulation]; dosetime = DoseTime(dose = 100, time = 0))
sort!(dsnca, :Subject)
dsnca[:, :AUClast]
```
## PD subject
Use [`pdimport`](@ref) to import PD data from table to subject set.
#### Import & NCA
```@example ncaexample
pddata = CSV.File(joinpath(dirname(pathof(MetidaNCA)), "..", "test", "csv", "pddata.csv")) |> DataFrame
pd = MetidaNCA.pdimport(pddata, :time, :obs, :subj; bl = 1.5, th = 5.0)
MetidaNCA.nca!(pd[1])
```
#### PD subject plotting
```@example ncaexample
p = MetidaNCA.pkplot(pd[1], drawth = true, drawbl = true)
png(p, "plot6.png")
```
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | docs | 2093 | # MetidaNCA
```@meta
CurrentModule = MetidaNCA
```
Non-compartment pharmacokinetic analysis (NCA). The package is designed for batch processing of pharmacokinetic data.
*This program comes with absolutely no warranty. No liability is accepted for any loss and risk to public health resulting from use of this software.
*Always validate software with known results before use.
## NCA
Pharmacokinetics, sometimes abbreviated as PK, is a branch of pharmacology dedicated to determine the fate of substances administered to a living organism.
When analyzing pharmacokinetic data, one generally employs either model fitting using nonlinear regression analysis or non-compartmental analysis techniques (NCA). The method one actually employs depends on what is required from the analysis. If the primary requirement is to determine the degree of exposure following administration of a drug (such as AUC), and perhaps the drug's associated pharmacokinetic parameters, such as clearance, elimination half-life, T (max), C (max), etc., then NCA is generally the preferred methodology to use in that it requires fewer assumptions than model-based approaches.
## Validation
Validation report: [validation_report.pdf](./validation_report.pdf).
Appendix 2: [Appendix2.1.pdf](./pdf/Appendix2.1.pdf), [Appendix2.2.pdf](./pdf/Appendix2.2.pdf), [Appendix2.3.pdf](./pdf/Appendix2.3.pdf), [Appendix2.4.pdf](./pdf/Appendix2.4.pdf), [Appendix2.5.pdf](./pdf/Appendix2.5.pdf).
## Unitful
See [Unitful details](@ref unitful_details).
## Contents
```@contents
Pages = [
"examples.md",
"parameters.md",
"api.md",
]
Depth = 3
```
## Reference
* Makoid C, Vuchetich J, Banakar V (1996-1999), Basic Pharmacokinetics;
* Gabrielsson and Weiner (1997), Pharmacokinetic and Pharmacodynamic Data Analysis: Concepts and Applications;
* Gibaldi and Perrier (1982), Pharmacokinetics;
* Wagner (1975), Fundamentals of Clinical Pharmacokinetics.
* Gabrielsson J, Weiner D. Non-compartmental analysis. Methods Mol Biol. 2012;929:377-89. doi: 10.1007/978-1-62703-050-2_16. PMID: 23007438.
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.5.13 | e7a74076e469eb9611b204bab0cc9e5c69453894 | docs | 4271 | # [Parameter list](@id parameter_list)
## Basic parameters
### :Cmax
Maximum concentration from dose time to dose time + tau (if tau > 0). Firs observation used.
### :Tmax
Time at maximum concentration from dose time to dose time + tau (if tau > 0). Firs observation used.
### :Cdose
By default dose time is 0. If concentration at dose time present in observation list - this concentration will be used.
For extravascular setting (:ev) if τ used (τ > 0) Cdose set as minimum concentration from dose time to τ time [:Ctaumin](#:Ctaumin), else set equal to zero.
For IV (:iv) if 1-st observation > 2-nd observation > 0 then logarithmic extrapolation used, else set equal to 1-st observation.
### AUC / AUMC
Area under Curve / Area under the Moment Curve.
```math
AUC = \sum_{n=1}^N AUC_{n}
```
```math
AUMC = \sum_{n=1}^N AUMC_{n}
```
Where `AUCn`/`AUMCn`- partial AUC/AUMC.
#### Linear trapezoidal rule
```math
AUC\mid_{t_1}^{t_2} = \delta t \times \frac{C_1 + C_2}{2}
```
```math
AUMC\mid_{t_1}^{t_2} = \delta t \times \frac{t_1 \times C_1 + t_2 \times C_2}{2}
```
#### Logarithmic trapezoidal rule
```math
AUC\mid_{t_1}^{t_2} = \delta t \times \frac{ C_2 - C_1}{ln(C_2/C_1)}
```
```math
AUMC\mid_{t_1}^{t_2} = \delta t \times \frac{t_2 \times C_2 - t_1 \times C_1}{ln(C_2/C_1)} - \delta t^2 \times \frac{ C_2 - C_1}{ln(C_2/C_1)^2}
```
#### Interpolation
##### Linear interpolation rule
```math
C_x = C_1 + \frac{(t_x-t_1)\times(C_2 - C_1)}{t_2 - t_1}
```
##### Logarithmic interpolation rule
```math
C_x = exp\left(ln(C_1) + \frac{(t_x-t_1)\times(ln(C_2) - ln(C_1))}{t_2 - t_1}\right)
```
#### :AUClast
Area under the curve from dose time to last observed concentration (>0).
#### :AUMClast
Area under the Moment Curve from dose time to last observed concentration (>0).
Dose time is the starting point for this calculation.
#### :AUCall
All values used to calculate AUC.
### :Kel
𝝺z - elimination constant. Linear regression at the terminal phase used for logarithmic transformed concentration data.
### :HL
Half-Life; T1/2
```math
HL = ln(2) / \lambda_z
```
### :Rsq
Coefficient of determination (R²).
### :ARsq
Adjusted coefficient of determination (R²).
### :NpLZ
Number of points for elimination calculation.
### :MRTlast
Mean residence time (MRT) from the dose time to the time of the last observed concentration.
```math
MRT_{last} = AUMC_{last} / AUC_{last}
```
## If :Kel calculated
### :AUCinf
AUC extrapolated from the last observed concentration to infinity.
```math
AUC_\infty = AUC_{last} + \frac{C_{last}}{\lambda_z}
```
### :AUMCinf
AUMC extrapolated from the last observed concentration to infinity.
```math
AUMC_\infty = AUMC_{last} + \frac{t_{last}\times C_{last}}{\lambda_z} + \frac{C_{last}}{\lambda_z^2}
```
### :AUCpct
Percentage of AUCinf due to extrapolation from the last observed concentration to infinity.
```math
AUCpct = (AUC_\infty - AUC_{last}) / AUC_\infty * 100 \%
```
#### :AUCinf_pred
AUC extrapolated to infinity from the predicted concentration.
```math
AUC_{\infty pred} = AUC_{last} + \frac{C_{last pred}}{\lambda_z}
```
## If Dose used
### Clearance
#### :Cllast
```math
CL_{last} = Dose / AUC_{last}
```
#### :Clinf
Total body clearance for extravascular administration.
```math
CL_\infty = Dose / AUC_\infty
```
#### :Vzinf
Volume of distribution based on the terminal phase.
## Steady-state parameters (If τ used)
τ-time = dose_time + τ
### :AUCtau
Area under the curve from dose time to τ-time.
### :AUMCtau
Area under the Moment Curve from the dose time to τ-time.
### :Ctau
Concentration at τ-time.
### :Ctaumin
Minimum concentration from the dose time to τ-time.
### :Cavg
```math
C_{avg} = AUC_\tau / \tau
```
### :Fluc
Fluctuation
```math
Fluc = ( C_{max} - C_{\tau min} ) / C_{avg} * 100 \%
```
### :Fluctau
Fluctuation Tau
```math
Fluc\tau = ( C_{max} - C_{\tau} ) / C_{avg} * 100 \%
```
### :Accind
Accumulation index.
```math
Accind = \frac{1}{1 - exp(-\lambda_z \tau)}
```
### :MRTtauinf
```math
MRT_{\tau\inf} = (AUMC_\tau + \tau * (AUC_\infty - AUC_\tau)) / AUC_\tau
```
### :Swing
```math
Swing = (C_{max} - C_{\tau min}) / C_{\tau min}
```
### :Swingtau
```math
Swing_{\tau} = (C_{max} - C_{\tau}) / C_{\tau}
```
| MetidaNCA | https://github.com/PharmCat/MetidaNCA.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 1420 | using Documenter, Microstructure
push!(LOAD_PATH, "../src/")
mathengine = MathJax3(
Dict(
:loader => Dict("load" => ["[tex]/require", "[tex]/mathtools"]),
:tex => Dict(
"inlineMath" => [["\$", "\$"], ["\\(", "\\)"]],
"packages" => ["base", "ams", "autoload", "mathtools", "require"],
),
),
)
makedocs(;
sitename="Microstructure.jl",
authors="Ting Gong",
modules=[Microstructure],
clean=true,
doctest=false,
linkcheck=true,
warnonly=[:docs_block, :missing_docs, :cross_references, :linkcheck],
format = Documenter.HTML(;
mathengine=mathengine,
sidebar_sitename = false,
prettyurls = get(ENV, "CI", nothing) == "true"
),
pages=[
"Home" => "index.md",
"Getting started" => "getting_started.md",
"Manual" => Any[
"manual/dMRI.md",
"manual/compartments.md",
"manual/models.md",
"manual/estimators.md",
"manual/multithreads.md",
],
"Tutorials" => Any[
"tutorials/1_build_models.md",
"tutorials/2_quality_of_fit.md",
"tutorials/3_data_generation.md",
"tutorials/4_noise_propagation.md",
"tutorials/5_model_selection.md",
],
"guide.md",
],
)
deploydocs(; repo="github.com/Tinggong/Microstructure.jl.git", push_preview=true)
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 249 | # Development version
module Microstructure
include("dMRI.jl")
include("values.jl")
include("compartments.jl")
include("models_smt.jl")
include("estimators_mcmc.jl")
include("estimators_nn.jl")
include("threading.jl")
include("diagnostics.jl")
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 16305 | # This script builds compartment structs with fields of relevant tissue parameters and
# forward functions inferencing signals from the compartment model and imaging protocol.
#
# Featuring spherical mean based models with compartmental relaxation-weighting.
using LinearAlgebra, SpecialFunctions
export Cylinder,
Stick,
Zeppelin,
Iso,
Sphere,
compartment_signals,
Compartment,
smt_signals
# export compartment_signals!, smt_signals!
"""
Compartment Type is an abstract type that includes the `Cylinder`, `Stick`, `Zeppelin`, `Sphere` and `Iso` type.
A Compartment Type object contains relevant tissue parameters that affect the MRI signals.
Each type of compartment contain a `t2` field for combined-diffusion-T2 imaging.
When your data supports only T2-weighted compartment modelling, i.e. acquired with single-TE,
set the `t2` field to zero for conventional dMRI modelling.
"""
abstract type Compartment end
"""
Cylinder(
da::Float64,
dpara::Float64,
d0::Float64,
t2::Float64
)
Return a Cylinder Type object with the cylinder diameter `da`, parallel diffusivity `dpara`,
the intrinsic diffusivity `d0` and the T2 relaxation time `t2`.
# Examples
```julia-repl
julia> Cylinder(da = 3.0e-6, dpara = 1.8e-9, d0 = 1.7e-9, t2 = 90e-3)
Cylinder(3.0e-6, 1.8e-9, 1.7e-9, 0.09)
```
"""
Base.@kwdef mutable struct Cylinder <: Compartment
da::Float64 = 3.0e-6
dpara::Float64 = 0.6e-9
d0::Float64 = 0.6e-9
t2::Float64 = 0.0
end
"""
Stick(dpara::Float64, t2::Float64)
Return a Stick Type object with parallel diffusivity `dpara` and T2 relaxation time `t2`.
The perpendicular diffusivity of a Stick model is zero.
# Examples
```julia-repl
julia> Stick(dpara = 1.7e-6, t2 = 60e-3)
Stick(1.7e-6, 0.06)
```
"""
Base.@kwdef mutable struct Stick <: Compartment
dpara::Float64 = 0.6e-9
t2::Float64 = 0.0
end
"""
Zeppelin(
dpara::Float64,
dperp_frac::Float64,
t2::Float64
)
Return a Zeppelin Type object with parallel diffusivity `dpara`, axially symmetric
perpendicular diffusivity represented as a fraction of the parallel diffusivity `dperp_frac`,
and the T2 relaxation time `t2`.
# Examples
```julia-repl
julia> Zeppelin(dpara = 1.7e-6, dperp_frac = 0.5, t2 = 0.0)
Zeppelin(1.7e-6, 0.5, 0.0)
```
"""
Base.@kwdef mutable struct Zeppelin <: Compartment
dpara::Float64 = 0.6e-9
dperp_frac::Float64 = 0.5
t2::Float64 = 0.0
end
"""
Sphere(
diff::Float64,
size::Float64,
t2::Float64
)
Return a Sphere Type object with diffusivity within sphere `diff`, spherical radius `size`,
and T2 relaxation time `t2`.
# Examples
```julia-repl
julia> Sphere(diff = 3.0e-9, size = 8.0e-6, t2 = 45e-3)
Sphere(3.0e-9, 8.0e-6, 0.045)
```
"""
Base.@kwdef mutable struct Sphere <: Compartment
diff::Float64 = 2e-9
size::Float64 = 4e-6
t2::Float64 = 0.0
end
"""
Iso(diff::Float64, t2=Float64)
Return an isotropic tensor with diffusivity `diff` and T2 relaxation time `t2`.
This compartment can be used to represent CSF (`diff` = free water) or dot compartment (`diff` = 0).
The latter is for immobile water typically seen in ex vivo tissue.
This compartment can also represent an isotropic extra-cellular environment with diffusivity `diff` slower than free water.
# Examples
```julia-repl
julia> Iso(diff = 3.0e-9,t2 = 2000.0e-3)
Iso(3.0e-9, 2.0)
```
```julia-repl
julia> Iso(diff = 0.0)
Iso(0.0, 0.0)
```
"""
Base.@kwdef mutable struct Iso <: Compartment
diff::Float64 = 2e-9
t2::Float64 = 0.0
end
"""
compartment_signals(model::Compartment,protocol::Protocol)
Return compartment signals given a compartment object `model` and a imaging `protocol`.
`model` can be the `Cylinder`/`Zeppelin`/`Stick`/`Sphere`/`Iso` Type. When `t2` in compartment `model` is set as default (0),
relaxation-weightings are not considered in the signal equation.
### References
If you use these compartments to build models, please cite the recommended references.
# For using any compartment in current release, please cite the following references for expressions of spherical mean/power averaging:
Callaghan, P.T., Jolley, K.W., Lelievre, J., 1979. Diffusion of water in the endosperm tissue of wheat grains as studied by pulsed field gradient nuclear magnetic resonance. Biophys J 28, 133. https://doi.org/10.1016/S0006-3495(79)85164-4
Kroenke, C.D., Ackerman, J.J.H., Yablonskiy, D.A., 2004. On the nature of the NAA diffusion attenuated MR signal in the central nervous system. Magn Reson Med 52, 1052–1059. https://doi.org/10.1002/MRM.20260
Kaden, E., Kruggel, F., Alexander, D.C., 2016. Quantitative mapping of the per-axon diffusion coefficients in brain white matter. Magn Reson Med 75, 1752–1763. https://doi.org/10.1002/MRM.25734
# Consider the following reference for overview of all tissue compartments:
Panagiotaki, E., Schneider, T., Siow, B., Hall, M.G., Lythgoe, M.F., Alexander, D.C., 2012. Compartment models of the diffusion MR signal in brain white matter: A taxonomy and comparison. Neuroimage 59, 2241–2254.
# Cylinder compartment:
Van Gelderen, P., Des Pres, D., Van Zijl, P.C.M., Moonen, C.T.W., 1994. Evaluation of Restricted Diffusion in Cylinders. Phosphocreatine in Rabbit Leg Muscle. J Magn Reson B 103, 255–260. https://doi.org/10.1006/JMRB.1994.1038
Alexander, D.C., Hubbard, P.L., Hall, M.G., Moore, E.A., Ptito, M., Parker, G.J.M., Dyrby, T.B., 2010. Orientationally invariant indices of axon diameter and density from diffusion MRI. Neuroimage 52, 1374–1389. https://doi.org/10.1016/j.neuroimage.2010.05.043
Fan, Q., Nummenmaa, A., Witzel, T., Ohringer, N., Tian, Q., Setsompop, K., Klawiter, E.C., Rosen, B.R., Wald, L.L., Huang, S.Y., 2020. Axon diameter index estimation independent of fiber orientation distribution using high-gradient diffusion MRI. Neuroimage 222.
Andersson, M., Pizzolato, M., Kjer, H.M., Skodborg, K.F., Lundell, H., Dyrby, T.B., 2022. Does powder averaging remove dispersion bias in diffusion MRI diameter estimates within real 3D axonal architectures? Neuroimage 248.
# Sphere compartment:
Neuman, C.H., 1974. Spin echo of spins diffusing in a bounded medium. J Chem Phys 4508–4511. https://doi.org/10.1063/1.1680931
Balinov, B., Jönsson, B., Linse, P., Söderman, O., 1993. The NMR Self-Diffusion Method Applied to Restricted Diffusion. Simulation of Echo Attenuation from Molecules in Spheres and between Planes. J Magn Reson A 104, 17–25. https://doi.org/10.1006/JMRA.1993.1184
# Stick compartment:
Behrens, T.E.J., Woolrich, M.W., Jenkinson, M., Johansen-Berg, H., Nunes, R.G., Clare, S., Matthews, P.M., Brady, J.M., Smith, S.M., 2003. Characterization and Propagation of Uncertainty in Diffusion-Weighted MR Imaging. Magn Reson Med 50, 1077–1088. https://doi.org/10.1002/MRM.10609
Panagiotaki, E., Schneider, T., Siow, B., Hall, M.G., Lythgoe, M.F., Alexander, D.C., 2012. Compartment models of the diffusion MR signal in brain white matter: A taxonomy and comparison. Neuroimage 59, 2241–2254.
Zhang, H., Schneider, T., Wheeler-Kingshott, C.A., Alexander, D.C., 2012. NODDI: Practical in vivo neurite orientation dispersion and density imaging of the human brain. Neuroimage 61, 1000–1016. https://doi.org/10.1016/j.neuroimage.2012.03.072
# Zeppelin & Iso:
Alexander, D.C., 2008. A General Framework for Experiment Design in Diffusion MRI and Its Application in Measuring Direct Tissue-Microstructure Features. Magn Reson Med 60, 439–448. https://doi.org/10.1002/mrm.21646
Panagiotaki, E., Schneider, T., Siow, B., Hall, M.G., Lythgoe, M.F., Alexander, D.C., 2012. Compartment models of the diffusion MR signal in brain white matter: A taxonomy and comparison. Neuroimage 59, 2241–2254.
Zhang, H., Schneider, T., Wheeler-Kingshott, C.A., Alexander, D.C., 2012. NODDI: Practical in vivo neurite orientation dispersion and density imaging of the human brain. Neuroimage 61, 1000–1016. https://doi.org/10.1016/j.neuroimage.2012.03.072
# Compartmental T2-weighting:
Veraart, J., Novikov, D.S., Fieremans, E., 2017. TE dependent Diffusion Imaging (TEdDI) distinguishes between compartmental T 2 relaxation times. https://doi.org/10.1016/j.neuroimage.2017.09.030
Lampinen, B., Szczepankiewicz, F., Novén, M., van Westen, D., Hansson, O., Englund, E., Mårtensson, J., Westin, C.F., Nilsson, M., 2019. Searching for the neurite density with diffusion MRI: Challenges for biophysical modeling. Hum Brain Mapp 40, 2529–2545. https://doi.org/10.1002/hbm.24542
Gong, T., Tong, Q., He, H., Sun, Y., Zhong, J., Zhang, H., 2020. MTE-NODDI: Multi-TE NODDI for disentangling non-T2-weighted signal fractions from compartment-specific T2 relaxation times. Neuroimage 217. https://doi.org/10.1016/j.neuroimage.2020.116906
Gong, T., Tax, C.M., Mancini, M., Jones, D.K., Zhang, H., Palombo, M., 2023. Multi-TE SANDI: Quantifying compartmental T2 relaxation times in the grey matter. Toronto.
"""
function compartment_signals(model::Cylinder, prot::Protocol)
# use this vector repeatedly to collect signals
signals = zeros(length(prot.bval))
# these two steps are not counted in allocations when using StaticVectors (for BesselJ_Roots)
alphm = BesselJ_RootsCylinder ./ (model.da ./ 2.0)
c1 =
1.0 ./ (
model.d0 .^ 2.0 .* alphm .^ 6.0 .*
((model.da ./ 2.0) .^ 2.0 .* alphm .^ 2.0 .- 1.0)
)
# these two will not be allocated if protocol is decleared using SVector
c2 = .-prot.tsmalldel .- prot.tdelta
c3 = prot.tsmalldel .- prot.tdelta
### this is not faster
#signals = MVector{N,Float64}(zeros(length(prot.bval),))
#c2 = SVector{N,Float64}(-prot.tsmalldel .- prot.tdelta)
#c3 = SVector{N,Float64}(prot.tsmalldel .- prot.tdelta)
for i in 1:(10::Int) # up to 10th order
a = model.d0 .* alphm[i] .^ 2.0
signals .=
signals .+
c1[i] .* (
2.0 .* a .* prot.tsmalldel .- 2.0 .+ 2.0 .* exp.(-a .* prot.tsmalldel) .+
2.0 .* exp.(-a .* prot.tdelta) .- exp.(a .* c2) .- exp.(a .* c3)
)
end
signals .= -2 .* gmr .^ 2 .* prot.gvec .^ 2 .* signals
signals .=
exp.(signals) .* sqrt.(pi ./ 4.0 ./ (prot.bval .* model.dpara .+ signals)) .*
erf.(sqrt.(prot.bval .* model.dpara .+ signals))
signals[findall(iszero, prot.bval)] .= 1.0
iszero(model.t2) && return signals
return signals .* exp.(-prot.techo ./ model.t2)
end
# Stick signals
function compartment_signals(model::Stick, prot::Protocol)
signals = smt_signals(prot, model.dpara, 0.0)
iszero(model.t2) && return signals
return signals .* exp.(-prot.techo ./ model.t2)
end
# Zeppelin signals
function compartment_signals(model::Zeppelin, prot::Protocol)
dperp = model.dpara .* model.dperp_frac
signals = smt_signals(prot, model.dpara, dperp)
iszero(model.t2) && return signals # t2 not considered
return signals .* exp.(-prot.techo ./ model.t2)
end
# Sphere signals
function compartment_signals(model::Sphere, prot::Protocol)
signals = zeros(length(prot.tdelta))
alphm = BesselJ_RootsSphere ./ model.size
c1 = alphm .^ (-4.0) ./ (alphm .^ 2.0 .* model.size .^ 2.0 .- 2.0)
c2 = -prot.tsmalldel .- prot.tdelta
c3 = prot.tsmalldel .- prot.tdelta
for i in 1:(31::Int) #eachindex(alphm)
a = model.diff .* alphm[i] .^ 2.0
signals .=
signals .+
c1[i] .* (
2.0 .* prot.tsmalldel .-
(
2.0 .+ exp.(a .* c3) .- 2.0 .* exp.(-a .* prot.tsmalldel) .-
2.0 .* exp.(-a .* prot.tdelta) .+ exp.(a .* c2)
) ./ a
)
end
signals .= exp.(-2.0 .* gmr .^ 2.0 .* prot.gvec .^ 2.0 ./ model.diff .* signals)
signals[findall(iszero, prot.bval)] .= 1.0
iszero(model.t2) && return signals # t2 not considered
return signals .* exp.(-prot.techo ./ model.t2)
end
# Isotropic signals
function compartment_signals(model::Iso, prot::Protocol)
iszero(model.t2) && return exp.(-prot.bval .* model.diff)
return exp.(-prot.bval .* model.diff .- prot.techo ./ model.t2)
end
# Spherical mean signals given parallel and perpendicular diffusivities
function smt_signals(prot::Protocol, dpara::Float64, dperp::Float64)
signals = prot.bval .* (dpara .- dperp)
signals .=
exp.(-prot.bval .* dperp) .* sqrt.(pi ./ 4.0 ./ signals) .* erf.(sqrt.(signals))
signals[findall(iszero, prot.bval)] .= 1.0
return signals
end
###################### to test mutating functions ######################################
"""
under testing mutating signals
"""
function compartment_signals!(signals::Vector{Float64}, model::Cylinder, prot::Protocol)
# set to 0 and collect signals
signals .= 0.0
# these two steps are not counted in allocations when using StaticVectors (for BesselJ_Roots)
alphm = BesselJ_RootsCylinder ./ (model.da ./ 2.0)
c1 =
1.0 ./ (
model.d0 .^ 2.0 .* alphm .^ 6.0 .*
((model.da ./ 2.0) .^ 2.0 .* alphm .^ 2.0 .- 1.0)
)
# these two will not be allocated if protocol is decleared using SVector
c2 = .-prot.tsmalldel .- prot.tdelta
c3 = prot.tsmalldel .- prot.tdelta
for i in 1:(10::Int) # up to 10th order
a = model.d0 .* alphm[i] .^ 2.0
signals .=
signals .+
c1[i] .* (
2.0 .* a .* prot.tsmalldel .- 2.0 .+ 2.0 .* exp.(-a .* prot.tsmalldel) .+
2.0 .* exp.(-a .* prot.tdelta) .- exp.(a .* c2) .- exp.(a .* c3)
)
end
signals .= -2 .* gmr .^ 2 .* prot.gvec .^ 2 .* signals
signals .=
exp.(signals) .* sqrt.(pi ./ 4.0 ./ (prot.bval .* model.dpara .+ signals)) .*
erf.(sqrt.(prot.bval .* model.dpara .+ signals))
signals[findall(iszero, prot.bval)] .= 1.0
iszero(model.t2) && return signals
signals .= signals .* exp.(-prot.techo ./ model.t2)
return signals
end
# Stick signals
function compartment_signals!(signals::Vector{Float64}, model::Stick, prot::Protocol)
smt_signals!(signals, prot, model.dpara, 0.0)
iszero(model.t2) && return signals
signals .= signals .* exp.(-prot.techo ./ model.t2)
return signals
end
# Zeppelin signals
function compartment_signals!(signals::Vector{Float64}, model::Zeppelin, prot::Protocol)
dperp = model.dpara .* model.dperp_frac
smt_signals!(signals, prot, model.dpara, dperp)
iszero(model.t2) && return signals # t2 not considered
signals .= signals .* exp.(-prot.techo ./ model.t2)
return signals
end
# Sphere signals
function compartment_signals!(signals::Vector{Float64}, model::Sphere, prot::Protocol)
signals .= 0.0
alphm = BesselJ_RootsSphere ./ model.size
c1 = alphm .^ (-4.0) ./ (alphm .^ 2.0 .* model.size .^ 2.0 .- 2.0)
c2 = -prot.tsmalldel .- prot.tdelta
c3 = prot.tsmalldel .- prot.tdelta
for i in 1:(31::Int) #eachindex(alphm)
a = model.diff .* alphm[i] .^ 2.0
signals .=
signals .+
c1[i] .* (
2.0 .* prot.tsmalldel .-
(
2.0 .+ exp.(a .* c3) .- 2.0 .* exp.(-a .* prot.tsmalldel) .-
2.0 .* exp.(-a .* prot.tdelta) .+ exp.(a .* c2)
) ./ a
)
end
signals .= exp.(-2.0 .* gmr .^ 2.0 .* prot.gvec .^ 2.0 ./ model.diff .* signals)
signals[findall(iszero, prot.bval)] .= 1.0
iszero(model.t2) && return signals # t2 not considered
signals .= signals .* exp.(-prot.techo ./ model.t2)
return signals
end
# Isotropic signals
function compartment_signals!(signals::Vector{Float64}, model::Iso, prot::Protocol)
signals .= exp.(-prot.bval .* model.diff)
iszero(model.t2) && return nothing
signals .= signals .* exp.(-prot.techo ./ model.t2)
return signals
end
# Spherical mean signals given parallel and perpendicular diffusivities
function smt_signals!(
signals::Vector{Float64}, prot::Protocol, dpara::Float64, dperp::Float64
)
signals .= prot.bval .* (dpara .- dperp)
signals .=
exp.(-prot.bval .* dperp) .* sqrt.(pi ./ 4.0 ./ signals) .* erf.(sqrt.(signals))
signals[findall(iszero, prot.bval)] .= 1.0
return signals
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 9718 | # I/O functions for images and protocols
# Include functions to perform direction average
using Fibers, DelimitedFiles, Statistics, StaticArrays
export dMRI,
Protocol,
spherical_mean,
spherical_mean!,
normalize_smt!,
dmri_write,
dmri_read,
dmri_read_times,
dmri_read_times!,
dmri_read_time
"""
dMRI(nifti::MRI,
tdelta::Vector{Float64},
dsmalldel::Vector{Float64},
techo::Vector{Float64},
smt::Bool)
Return a dMRI Type object with MRI object `nifti`, and additional volume-wise
experimental settings `tdelta`, `tsmalldel`, `techo`, and `smt` for identifing smt signals.
"""
mutable struct dMRI
nifti::MRI
tdelta::Vector{Float64}
tsmalldel::Vector{Float64}
techo::Vector{Float64}
smt::Bool
end
"""
initialize dMRI structure from MRI or Array
"""
dMRI(mri::MRI) = dMRI(
mri,
Vector{Float64}(zeros(mri.nframes)),
Vector{Float64}(zeros(mri.nframes)),
Vector{Float64}(zeros(mri.nframes)),
false,
)
"""
Read nifti and text files to dMRI object; variable number of input text files
"""
function dmri_read(imagefile::String, infiles::String...)
mri = mri_read(imagefile)
dmri = dmri_read_times(mri, infiles)
return dmri
end
"""
Called by dmri_read; Tuple holds variable number of input text files
Run alone to construct a dMRI from mri object and text files
"""
function dmri_read_times(mri::MRI, infiles::Tuple{Vararg{String}})
dmri = dMRI(mri)
dmri_read_times!(dmri, infiles)
# round b table; .element-wise openration
dmri.nifti.bval .= round.(dmri.nifti.bval ./ 50.0) .* 50.0
dmri.nifti.bval[dmri.nifti.bval .<= 100.0] .= 0.0
# set delta/smalldel to 0 when b = 0
index = iszero.(dmri.nifti.bval)
dmri.tdelta[index] .= 0.0
dmri.tsmalldel[index] .= 0.0
return dmri
end
"""
read txt files and update dMRI fields according to file extensions
"""
function dmri_read_times!(dmri::dMRI, infiles::Tuple{Vararg{String}})
for file in infiles
tab, ext = dmri_read_time(file)
if ext == "techo"
dmri.techo = vec(tab)
elseif ext == "tdelta"
dmri.tdelta = vec(tab)
elseif ext == "tsmalldel"
dmri.tsmalldel = vec(tab)
elseif ext == "bvals"
dmri.nifti.bval = vec(tab)
elseif ext == "bvecs"
dmri.nifti.bvec = tab
else
error("Unindentified file extension")
end
end
return dmri
end
"""
read vectors and get file extension from input file
"""
function dmri_read_time(infile::String)
if !isfile(infile)
error("Could not find input file")
end
# find input file extention
idot = findlast(isequal('.'), infile)
ext = lowercase(infile[(idot + 1):end])
# read file
tab = readdlm(infile)
return tab, ext
end
"""
mutating dmri structure after direction averaging
"""
function spherical_mean!(dmri::dMRI)
if dmri.smt == true
error("The input contains already spherical mean signals")
end
# select unique combinations of bval, techo, tdelta, tsmalldel
sets = [dmri.nifti.bval dmri.techo dmri.tdelta dmri.tsmalldel]
combinations = unique(sets; dims=1)
# sortting to help check signals when bval/techo are not in assending order
ind = sortperm(combinations[:,1])
combinations = combinations[ind,:]
ind = sortperm(combinations[:,2])
combinations = combinations[ind,:]
# initialize new volume
nsets = size(combinations, 1)
volsize = size(dmri.nifti.vol)
vol = Array{AbstractFloat}(undef, volsize[1:3]..., nsets)
# direction average persets
for i in 1:nsets
index = []
for j in 1:volsize[4]
if sets[j, :] == combinations[i, :]
append!(index, j)
end
end
vol[:, :, :, i] .= mean(dmri.nifti.vol[:, :, :, index]; dims=4)
end
# update related fields
dmri.nifti.bval = combinations[:, 1]
dmri.techo = combinations[:, 2]
dmri.tdelta = combinations[:, 3]
dmri.tsmalldel = combinations[:, 4]
dmri.nifti.vol = vol
dmri.nifti.bvec = zeros(nsets, 3)
dmri.nifti.nframes = nsets
dmri.smt = 1
return nothing
end
"""
normalize signals with minimal TE and b=0 volume;
save the first volume (all 1) for the associated acquistion parameters in the normalizing volume
"""
function normalize_smt!(dmri::dMRI)
if dmri.nifti.bval[1] != 0
error("First volume is not from b=0")
end
nvol = length(dmri.nifti.bval)
vol_b0 = dmri.nifti.vol[:, :, :, 1]
for i in 1:nvol
dmri.nifti.vol[:, :, :, i] = dmri.nifti.vol[:, :, :, i] ./ vol_b0
end
return nothing
end
"""
Apply universal scaling to smt signals
"""
function scale_smt!(dmri::dMRI)
end
"""
spherical_mean(
image_file::String,
save::Bool=true,
acq_files::String...
)
Perform direction average on input DWI images `image_file` and return an MRI object with normalized spherical mean signal and associated imaging protocol.
`image_file` is the full path of the DWI image file; `save` indicates whether to save the smt and normalized smt image volumes and protocol. If saving the files, nifti and text file (.btable) will be saved in the same path as the input data.
Finall, variable number of `acq_files` are text files that tell you acquistion parameters of each DWI in the `image_file`.
Accepted file extensions are .bvals/.bvecs/.techo/.tdelta/.tsmalldel for b-values, gradient directions, echo times, diffusion gradient seperation and duration times.
Besides .bvals/.bvecs for conventional modelling, .tdelta/.tsmalldel files are needed for any models that estimate size, e.g. axon diameter, soma radius.
.techo is needed if your data is collected with multiple echo-time and you want to do combined-diffusion relaxometry modelling.
The format of a .tdelta/.tsmalldel/.techo file is similar to a .bvals file (a vector with the length equal to the number of DWI volumes).
Unit in the .tdelta/.tsmalldel/.techo file is ms.
"""
function spherical_mean(
infile_image::String, save::Bool=true, infiles::String...
)
mri = mri_read(infile_image)
dmri = dmri_read_times(mri, infiles)
spherical_mean!(dmri)
if save
datapath = infile_image[1:findlast(isequal('/'), infile_image)]
dmri_write(dmri, datapath, "diravg.nii.gz")
end
# default to normalize signals
normalize_smt!(dmri)
if save
datapath = infile_image[1:findlast(isequal('/'), infile_image)]
dmri_write(dmri, datapath, "diravg_norm.nii.gz")
end
prot = Protocol(dmri)
return dmri.nifti, prot
end
"""
dmri_write(dmri::dMRI, datapath::String, filename::String)
Write the nifti volume in a dMRI object to nifti file and associated protocol as b-table text files in the given `datapath` and `filename`.
"""
function dmri_write(dmri::dMRI, datapath::String, outfile::String)
mri_write(dmri.nifti, datapath * outfile)
# find input file name
idot = findfirst(isequal('.'), outfile)
name = lowercase(outfile[1:(idot - 1)])
prot = Protocol(dmri)
btable = hcat(prot.bval, prot.techo, prot.tdelta, prot.tsmalldel, prot.gvec)
writedlm(datapath * name * ".btable", btable, ' ')
return nothing
end
"""
Protocol(
bval::Vector{Float64}
techo::Vector{Float64}
tdelta::Vector{Float64}
tsmalldel::Vector{Float64}
gvec::Vector{Float64}
)
Return a Protocol Type object to hold parameters in acquisition protocol relavent for modelling
including b-values, tcho times, diffusion gradient seperation, duration and strengh.
Unit convention: most text files use s/mm^2 for b-values and ms for time while they are converted to SI unit in the Protocol.
b-values (s/m^2); time (s); size (m); G (T/m)
Protocol(
filename::String
)
Return a Protocol Type object from a b-table file generated from spherical_mean function.
Protocol(
bval::Vector{Float64},
techo::Vector{Float64},
tdelta::Vector{Float64},
tsmalldel::Vector{Float64},
)
Calculate `gvec` and return a Ptotocol Type object from provided parameters.
"""
struct Protocol
bval::Vector{Float64}
techo::Vector{Float64}
tdelta::Vector{Float64}
tsmalldel::Vector{Float64}
gvec::Vector{Float64}
#bvec::AbstractMatrix{Float64}
#qvec=gmr.*tsmalldel.*gvec
end
# make protocols from acq vectors
#function Protocol(bval::SVector{<:Any,Float64}, techo::SVector{<:Any,Float64}, tdelta::SVector{<:Any,Float64}, tsmalldel::SVector{<:Any,Float64})
# gvec = 1.0 ./ gmr ./ tsmalldel .* sqrt.(bval ./ (tdelta .- tsmalldel ./ 3.0))
# Protocol(bval, techo, tdelta, tsmalldel, gvec)
#end
function Protocol(
bval::Vector{Float64},
techo::Vector{Float64},
tdelta::Vector{Float64},
tsmalldel::Vector{Float64},
)
gvec = 1.0 ./ gmr ./ tsmalldel .* sqrt.(bval ./ (tdelta .- tsmalldel ./ 3.0))
return Protocol(bval, techo, tdelta, tsmalldel, gvec)
end
"""
Make protocol from a dMRI object
"""
function Protocol(dmri::dMRI)
return Protocol(
dmri.nifti.bval .* 1.0e6,
dmri.techo .* 1.0e-3,
dmri.tdelta .* 1.0e-3,
dmri.tsmalldel .* 1.0e-3,
)
end
# make protocol from btable file
function Protocol(infile::String)
if !isfile(infile)
error("Could not find btable file")
end
# find input file extention
idot = findlast(isequal('.'), infile)
ext = lowercase(infile[(idot + 1):end])
if ext != "btable"
error("Input is not a btable")
end
# read file and make protocol
tab = readdlm(infile)
return Protocol(tab[:, 1], tab[:, 2], tab[:, 3], tab[:, 4], tab[:, 5])
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 6916 | using MCMCDiagnosticTools, Statistics
using DataFrames, Gadfly
export Sampler, run_diagnostics, plot_diagnostics
"""
Change the number of samples in a sampler
"""
function Sampler(sampler::Sampler, nsamples::Int64)
return Sampler(;
params=sampler.params,
prior_range=sampler.prior_range,
proposal=sampler.proposal,
paralinks=sampler.paralinks,
nsamples=nsamples,
burnin=sampler.burnin,
thinning=sampler.thinning,
)
end
"""
run_diagnostics(
meas::Vector{Float64},
protocol::Protocol,
model_start::BiophysicalModel,
sampler::Sampler,
draws::Vector{Int64},
rng_seed::Int64=1,
noise::Noisemodel=Noisemodel(),
)
Return chain diagnostics tested with different sampling length. This function is useful for optimizing sampler for a given model.
# References
Vehtari, A., Gelman, A., Simpson, D., Carpenter, B. and Bürkner, P.C., 2021. Rank-normalization, folding, and localization: An improved R ̂ for assessing convergence of MCMC (with discussion). Bayesian analysis, 16(2), pp.667-718.
"""
function run_diagnostics(
meas::Vector{Float64},
protocol::Protocol,
model_start::BiophysicalModel,
sampler::Sampler,
draws::Vector{Int64},
rng_seed::Int64=1,
noise::Noisemodel=Noisemodel(),
)
ratio = zeros(length(draws))
diagnostics = DataFrame(;
Parameters=String[],
NSamples=Int[],
ESS=Float64[],
SplitR=Float64[],
MCSE=Float64[],
Estimate=Float64[],
ErrorRatio=Float64[],
)
for (i, nsamples) in enumerate(draws)
sampler = Sampler(sampler, nsamples)
chain = mcmc!(model_start, meas, protocol, sampler, noise, rng_seed)
for para in sampler.params
if chain[para][1] isa Vector
fracs = reduce(hcat, chain[para])
for i in axes(fracs, 1)
diagns = ess_rhat(fracs[i, (sampler.burnin + 1):end]; split_chains=2)
se = mcse(fracs[i, (sampler.burnin + 1):end]; kind=Statistics.mean)
estimate = mean(fracs[i, (sampler.burnin + 1):(sampler.thinning):end])
push!(
diagnostics,
(
"f" * string(i),
nsamples,
diagns[:ess],
diagns[:rhat],
se,
estimate,
se / estimate,
),
)
end
else
diagns = ess_rhat(chain[para][(sampler.burnin + 1):end]; split_chains=2)
se = mcse(chain[para][(sampler.burnin + 1):end]; kind=Statistics.mean)
estimate = mean(chain[para][(sampler.burnin + 1):(sampler.thinning):end])
push!(
diagnostics,
(
para,
nsamples,
diagns[:ess],
diagns[:rhat],
se,
estimate,
se / estimate,
),
)
end
end
ratio[i] = sum(chain["move"]) / nsamples
end
return diagnostics, ratio
end
function run_diagnostics(
meas::Vector{Float64},
protocol::Protocol,
model_start::BiophysicalModel,
sampler::Tuple{Sampler,Sampler},
draws::Vector{Int64},
rng_seed::Int64=1,
noise::Noisemodel=Noisemodel(),
)
ratio = zeros(length(draws))
diagnostics = DataFrame(;
Parameters=String[],
NSamples=Int[],
ESS=Float64[],
SplitR=Float64[],
MCSE=Float64[],
Estimate=Float64[],
ErrorRatio=Float64[],
)
for (i, nsamples) in enumerate(draws)
sampler_full = Sampler(sampler[1], nsamples)
chain = mcmc!(model_start, meas, protocol, sampler_full, noise, rng_seed)
sampler_sub = Sampler(sampler[2], nsamples)
pertub = draw_samples(sampler_sub, noise, "dict")
mcmc!(chain, model_start, meas, protocol, sampler_sub, pertub, noise)
for para in sampler_full.params
if chain[para][1] isa Vector
fracs = reduce(hcat, chain[para])
for i in axes(fracs, 1)
diagns = ess_rhat(
fracs[i, (sampler_full.burnin + 1):end]; split_chains=2
)
se = mcse(fracs[i, (sampler_full.burnin + 1):end]; kind=Statistics.mean)
estimate = mean(
fracs[i, (sampler_full.burnin + 1):(sampler_full.thinning):end]
)
push!(
diagnostics,
(
"f" * string(i),
nsamples,
diagns[:ess],
diagns[:rhat],
se,
estimate,
se / estimate,
),
)
end
else
diagns = ess_rhat(
chain[para][(sampler_full.burnin + 1):end]; split_chains=2
)
se = mcse(chain[para][(sampler_full.burnin + 1):end]; kind=Statistics.mean)
estimate = mean(
chain[para][(sampler_full.burnin + 1):(sampler_full.thinning):end]
)
push!(
diagnostics,
(
para,
nsamples,
diagns[:ess],
diagns[:rhat],
se,
estimate,
se / estimate,
),
)
end
end
ratio[i] = sum(chain["move"]) / nsamples
end
return diagnostics, ratio
end
"""
Visualize diagnostics for model parameter
"""
function plot_diagnostics(diagno::DataFrame)
set_default_plot_size(30cm, 15cm)
p0 = Gadfly.plot()
p1 = Gadfly.plot(diagno, x=:NSamples, y=:ESS, color=:Parameters, Geom.point, Geom.line, linestyle=[:dash])
p2 = Gadfly.plot(diagno, x=:NSamples, y=:SplitR, color=:Parameters, Geom.point, Geom.line, linestyle=[:dash])
p3 = Gadfly.plot(diagno, x=:NSamples, y=:MCSE, color=:Parameters, Geom.point, Geom.line, linestyle=[:dash])
p4 = Gadfly.plot(diagno, x=:NSamples, y=:Estimate, color=:Parameters, Geom.point, Geom.line, linestyle=[:dash])
p5 = Gadfly.plot(diagno, x=:NSamples, y=:ErrorRatio, color=:Parameters, Geom.point, Geom.line, linestyle=[:dash])
return gridstack([p1 p2 p0; p3 p4 p5])
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 28790 | # MCMC estimation
using Random, Distributions, StaticArrays
export Sampler,
Noisemodel,
mcmc!,
subsampler,
logp_gauss,
logp_rician,
update!,
increment!,
getsubfield,
draw_samples,
draw_samples!,
findsubfield
"""
Noisemodel(logpdf::Function,
sigma_start::Float64,
sigma_range::Tuple{Float64,Float64},
proposal::Distribution)
Return a Noisemodel object with `logpdf` Function to calculate log likelihood of measurements (set this between `logp_gauss` and `logp_rician`),
`sigma_start` as the starting value of noise level, `sigma_range` as prior range and `proposal` distribution for MCMC sampling.
# Examples
```julia-repl
julia> Noisemodel()
Noisemodel(Microstructure.logp_gauss, 0.01, (0.005, 0.1), Distributions.Normal{Float64}(μ=0.0, σ=0.005))
```
```julia-repl
julia> Noisemodel(logpdf = logp_rician, sigma_start = 0.02, proposal = Normal(0,0.001))
Noisemodel(Microstructure.logp_rician, 0.02, (0.005, 0.1), Normal{Float64}(μ=0.0, σ=0.001))
```
"""
Base.@kwdef struct Noisemodel
logpdf::Function = logp_gauss
sigma_start::Float64 = 0.01
sigma_range::Tuple{Float64,Float64} = (0.001, 0.1)
proposal::Distribution = Normal(0, 0.005)
end
"""
logp_gauss(measurements, predictions, sigma)
logpdf with Gaussian noise model.
`sigma` is the standard deviation of Gaussian noise
"""
function logp_gauss(measurements::Vector{Float64}, predictions::Vector{Float64}, sigma::Float64)
# test adapted changes when including first b0 measurement
preds = @view predictions[2:end]
meas = @view measurements[2:end]
n = length(preds)
return -sum((preds .- meas) .^ 2.0) ./ 2.0 ./ sigma .^ 2.0 .-
n ./ 2.0 .* log.(2.0 .* pi .* sigma .^ 2.0)
end
"""
logp_rician(measurements, predictions, sigma)
logpdf with Rician noise model
`sigma` is the standard deviation of the Gaussian noise underlying the Rician noise
"""
function logp_rician(measurements::Vector{Float64}, predictions::Vector{Float64}, sigma::Float64)
# test adapted changes when including first b0 measurement
preds = @view predictions[2:end]
meas = @view measurements[2:end]
return logpdf(Product(Rician.(preds, sigma)), meas)
end
"""
Sampler(
params::Tuple{Vararg{String}},
prior_range::Tuple{Vararg{Tuple{Float64, Float64}}},
proposal::Tuple{Vararg{<:Any}},
paralinks::Tuple{Vararg{Pair{String}}},
nsamples::Int64
burnin::Int64
thinning::Int64
)
Return a Sampler Type object for a biophysical model.
# Examples
```julia-repl
julia>Sampler(
params = ("axon.da","axon.dpara","extra.dperp_frac","fracs"),
prior_range = ((1.0e-7,1.0e-5),(0.01e-9,0.9e-9),(0.0, 1.0),(0.0,1.0)),
proposal = (Normal(0,0.25e-6), Normal(0,0.025e-9), Normal(0,0.05), MvNormal([0.0025 0 0;0 0.0001 0; 0 0 0.0001])),
paralinks = ("axon.d0" => "axon.dpara", "extra.dpara" => "axon.dpara"),
nsamples = 70000,
burnin = 20000
)
Sampler(("axon.da", "axon.dpara", "extra.dperp_frac", "fracs"), ((1.0e-7, 1.0e-5), (1.0e-11, 9.0e-10), (0.0, 1.0), (0.0, 1.0)), (Normal{Float64}(μ=0.0, σ=2.5e-7), Normal{Float64}(μ=0.0, σ=2.5e-11), Normal{Float64}(μ=0.0, σ=0.05), ZeroMeanFullNormal(
dim: 3
μ: Zeros(3)
Σ: [0.0025 0.0 0.0; 0.0 0.0001 0.0; 0.0 0.0 0.0001]
)
), ("axon.d0" => "axon.dpara", "extra.dpara" => "axon.dpara"), 70000, 20000, 1)
```
"""
Base.@kwdef struct Sampler
params::Tuple{Vararg{String}} # parameters to sample
prior_range::Tuple{Vararg{Tuple{Float64,Float64}}} # range for priors
proposal::Tuple{Vararg{<:Any}} # proposal distributions
paralinks::Tuple{Vararg{Pair{String}}} = () # parameter links used in modelling
nsamples::Int64
burnin::Int64 = 0
thinning::Int64 = 1
end
"""
Draw pertubations used in MCMC
mutating pertubations
"""
function draw_samples!(
pertubations::Vector{<:Any}, sampler::Sampler, noise::Noisemodel=Noisemodel()
)
@inbounds for (i, para) in enumerate(sampler.params)
if para != "fracs"
pertubations[i] = rand(sampler.proposal[i], sampler.nsamples)
else
# convert the fraction matrix to vectors
pertubation = rand(sampler.proposal[i], sampler.nsamples)
pertubations[i] = [vec(pertubation[:, i]) for i in 1:(sampler.nsamples)]
end
end
return pertubations[end] = rand(noise.proposal, sampler.nsamples)
end
"""
draw_samples(sampler::Sampler, noise::Noisemodel , container::String)
Generate pertubations used in MCMC for tissue parameters and sigma using the proposals
"""
function draw_samples(sampler::Sampler, noise::Noisemodel, container::String)
if container == "vec"
pertubations = [
Vector{Any}(undef, sampler.nsamples) for i in 1:((1 + length(sampler.params))::Int)
]
@inbounds for (i, para) in enumerate(sampler.params)
pertubation = rand(sampler.proposal[i], sampler.nsamples)
if pertubation isa Vector
pertubations[i] = pertubation
else
pertubations[i] = [vec(pertubation[:, i]) for i in 1:(sampler.nsamples)]
end
end
pertubations[end] = rand(noise.proposal, sampler.nsamples)
elseif container == "dict"
pertubations = Dict()
@inbounds for (i, para) in enumerate(sampler.params)
# pertubation could be a vector or a matrix from multi-variant proposal
pertubation = rand(sampler.proposal[i], sampler.nsamples)
if pertubation isa Vector
push!(pertubations, para => pertubation)
else
push!(
pertubations, para => [vec(pertubation[:, i]) for i in 1:(sampler.nsamples)]
) # for vector fracs
end
end
push!(pertubations, "sigma" => rand(noise.proposal, sampler.nsamples))
else
error("use vec or dict")
end
return pertubations
end
"""
draw_samples(sampler::Sampler, container::String)
Generate pertubations used in MCMC for tissue parameters
"""
function draw_samples(sampler::Sampler, container::String)
if container == "vec"
pertubations = [
Vector{Any}(undef, sampler.nsamples) for i in 1:length(sampler.params)
]
@inbounds for (i, para) in enumerate(sampler.params)
pertubation = rand(sampler.proposal[i], sampler.nsamples)
if pertubation isa Vector
pertubations[i] = pertubation
else
pertubations[i] = [vec(pertubation[:, i]) for i in 1:(sampler.nsamples)]
end
end
elseif container == "dict"
pertubations = Dict()
@inbounds for (i, para) in enumerate(sampler.params)
# pertubation could be a vector or a matrix from multi-variant proposal
pertubation = rand(sampler.proposal[i], sampler.nsamples)
if pertubation isa Vector
push!(pertubations, para => pertubation)
else
push!(
pertubations, para => [vec(pertubation[:, i]) for i in 1:(sampler.nsamples)]
) # for vector fracs
end
end
else
error("use vec or dict")
end
return pertubations
end
"""
Define a subsampler sampling a subset of parameters in the sampler
using index vector for keeping parameters
"""
function subsampler(
sampler::Sampler, index::Vector{Int64}, paralinks::Tuple{Vararg{Pair{String}}}=()
)
params = sampler.params[index]
prior_range = sampler.prior_range[index]
proposal = sampler.proposal[index]
return Sampler(;
params=params, prior_range=prior_range, proposal=proposal, paralinks=paralinks, nsamples = sampler.nsamples, burnin = sampler.burnin, thinning = sampler.thinning
)
end
"""
After testing and optimizing sampler parameters for a model, add default sampler for the model for convenience here.
Examples given here are ExCaliber with two-stage MCMC and MTE_SMT; these sampling parameters are not optimised yet.
"""
function Sampler(model::BiophysicalModel, nsamples::Int64, burnin::Int64=0, thinning::Int64=1)
modeltype = typeof(model)
# tesing
if modeltype == ExCaliber
# set the tissue parameters you want to estimate in the model;
paras = ("axon.da", "axon.dpara", "extra.dperp_frac", "fracs")
# set parameter links
paralinks = ("axon.d0" => "axon.dpara", "extra.dpara" => "axon.dpara")
# set the range of priors and proposal distributions
pararange = ((1.0e-7, 1.0e-5), (0.01e-9, 0.9e-9), (0.0, 1.0), (0.0, 1.0))
# use MvNormal for proposal of fractions
proposal = (
Normal(0, 0.25e-6),
Normal(0, 0.025e-9),
Normal(0, 0.05),
MvNormal([0.0025 0;0 0.0001]), # 3-compartment model with 2 free fraction parameters
) #; equal to (Normal(0,0.05),Normal(0,0.01)) for fracs
# setup sampler and noise model
sampler = Sampler(;
params=paras, prior_range=pararange, proposal=proposal, paralinks=paralinks, nsamples = nsamples, burnin = burnin, thinning = thinning
)
return (sampler, subsampler(sampler, [1, 4], ()))
elseif modeltype == MTE_SMT
# under testing
params = ("axon.t2", "extra.dperp_frac", "extra.t2", "fracs")
prior_range = ((30e-3, 150e-3), (0.0, 1.0), (30e-3, 150e-3), (0.0, 1.0))
proposal = (
Normal(0, 10e-3),
Normal(0, 0.1),
Normal(0, 10e-3),
Normal(0, 0.1),
)
paralinks = ()
sampler = Sampler(;
params=params, prior_range=prior_range, proposal=proposal, paralinks=paralinks, nsamples = nsamples, burnin = burnin, thinning = thinning
)
return (sampler, subsampler(sampler, [1, 3, 4], ()))
elseif modeltype == MTE_SANDI
# under testing
elseif modeltype == SANDI
# under testing
else
error("Model not defined")
end
end
"""
Method 1 generates pertubations within function, creates and returns a dict chain, and modify final model estimates in place.
This method is useful in checking a few voxels, e.g. for quality of fitting, chain dignostics and optimizing sampler for models.
mcmc!(
estimates::BiophysicalModel,
meas::Vector{Float64},
protocol::Protocol,
sampler::Sampler,
noise::Noisemodel = Noisemodel(),
rng::Int64 = 1
)
```julia-repl
julia> chain = mcmc!(estimates, measurements, protocol, sampler, noise_model, rng)
```
Method 2 takes `chain` and `pertubations` as input, mutating `chain` in place which can be used to calculate finial estimates and uncertainties.
This method is used for processing larger dataset, e.g. for whole-barin/slices.
This method is used together with multi-threads processing that pre-allocate spaces for caching chains, avoiding creating them for each voxel.
This method also reuses `pertubations` for faster computation speed; we usually use very large numbers of pertubations (e.g. ~10^4) to densely sample the proposal distributions.
mcmc!(
chain::Vector{Any},
estimates::BiophysicalModel,
meas::Vector{Float64},
protocol::Protocol,
sampler::Sampler,
pertubations::Vector{Vector{Any}},
noise::Noisemodel = Noisemodel()
)
```julia-repl
julia> mcmc!(chain, estimates, meas, protocol, sampler, pertubations, noise_model))
```
# References
For using MCMC in microsturcture imaging, here are some recommended references:
Behrens, T.E.J., Woolrich, M.W., Jenkinson, M., Johansen-Berg, H., Nunes, R.G., Clare, S., Matthews, P.M., Brady, J.M., Smith, S.M., 2003. Characterization and Propagation of Uncertainty in Diffusion-Weighted MR Imaging. Magn Reson Med 50, 1077–1088. https://doi.org/10.1002/MRM.10609
Alexander, D.C., 2008. A General Framework for Experiment Design in Diffusion MRI and Its Application in Measuring Direct Tissue-Microstructure Features. Magn Reson Med 60, 439–448. https://doi.org/10.1002/mrm.21646
"""
function mcmc!(
estimates::BiophysicalModel,
meas::Vector{Float64},
protocol::Protocol,
sampler::Sampler,
noise::Noisemodel=Noisemodel(),
rng::Int64=1,
)
Random.seed!(rng)
# create chain and pertubations
chain = create_chain(sampler, "dict")
pertubations = draw_samples(sampler, noise, "dict")
# get logp_start from the start model and sigma defined in sampler and noise model object
sigma = noise.sigma_start
logp_start = noise.logpdf(meas, model_signals(estimates, protocol), sigma)
@inbounds for i in 1:(sampler.nsamples::Int)
# get current pertubation
pertubation = Tuple(para => pertubations[para][i] for para in sampler.params)
# get the next sample location and check if it is within prior ranges
outliers = increment!(estimates, pertubation, sampler.prior_range)
sigma += pertubations["sigma"][i]
if iszero(outliers) && !outlier_checking(sigma, noise.sigma_range)
# update linked parameters in model
update!(estimates, sampler.paralinks)
# update logp
logp_next = noise.logpdf(meas, model_signals(estimates, protocol), sigma)
# acception ratio
if rand(Float64) < min(1, exp(logp_next - logp_start))
move = 1
logp_start = copy(logp_next)
else
move = 0
# move estimates back to previous location
decrement!(estimates, pertubation)
update!(estimates, sampler.paralinks)
sigma -= pertubations["sigma"][i]
end
else
move = 0
# move next back to current location
decrement!(estimates, pertubation)
sigma -= pertubations["sigma"][i]
end
record_chain!(chain, estimates, sampler.params, i, move, sigma, logp_start)
end
#update model object as the mean values of selected samples
update!(
estimates,
Tuple(
para => mean(chain[para][(sampler.burnin+1):(sampler.thinning):end]) for
para in sampler.params
),
)
update!(estimates, sampler.paralinks)
return chain
end
# method 2.1: mutate vector chain and use provided vector pertubations; this is used in multi-threads processing large dataset
function mcmc!(
chain::Vector{Any},
estimates::BiophysicalModel,
meas::Vector{Float64},
protocol::Protocol,
sampler::Sampler,
pertubations::Vector{Vector{Any}},
noise::Noisemodel=Noisemodel(),
)
# get logp_start from the start model and sigma defined in sampler and noise model object
sigma = noise.sigma_start
logp_start = noise.logpdf(meas, model_signals(estimates, protocol), sigma)
N = length(sampler.params)
@inbounds for i in 1:(sampler.nsamples::Int)
# get current pertubation
pertubation = Tuple(sampler.params[j] => pertubations[j][i] for j in 1:(N::Int))
# get the next sample location and check if it is within prior ranges
outliers = increment!(estimates, pertubation, sampler.prior_range)
sigma += pertubations[end][i]
if iszero(outliers) && !outlier_checking(sigma, noise.sigma_range)
# update linked parameters in model
update!(estimates, sampler.paralinks)
# update logp
logp_next = noise.logpdf(meas, model_signals(estimates, protocol), sigma)
# acception ratio
if rand(Float64) < min(1, exp.(logp_next - logp_start))
move = 1
logp_start = copy(logp_next)
else
move = 0
# move estimates back to previous location
decrement!(estimates, pertubation)
update!(estimates, sampler.paralinks)
sigma -= pertubations[end][i]
end
else
move = 0
# move next back to current location
decrement!(estimates, pertubation)
sigma -= pertubations[end][i]
end
record_chain!(chain, estimates, sampler.params, i, move, sigma, logp_start)
end
#update model object as the mean values of selected samples
update!(
estimates,
Tuple(
sampler.params[j] => mean(chain[j][(sampler.burnin+1):(sampler.thinning):end]) for
j in 1:(N::Int)
),
)
update!(estimates, sampler.paralinks)
return nothing
end
# method 2.2: mutate dict chain and use provided dict pertubations; this is useful when doing two stage mcmc demonstration
function mcmc!(
chain::Dict{Any,Any},
estimates::BiophysicalModel,
meas::Vector{Float64},
protocol::Protocol,
sampler::Sampler,
pertubations::Dict{Any,Any},
noise::Noisemodel=Noisemodel(),
)
#empty_chain!(chain)
# get logp_start from the start model and sigma defined in sampler and noise model object
sigma = noise.sigma_start
logp_start = noise.logpdf(meas, model_signals(estimates, protocol), sigma)
@inbounds for i in 1:(sampler.nsamples::Int)
# get current pertubation
pertubation = Tuple(para => pertubations[para][i] for para in sampler.params)
# get the next sample location and check if it is within prior ranges
outliers = increment!(estimates, pertubation, sampler.prior_range)
sigma += pertubations["sigma"][i]
if iszero(outliers) && !outlier_checking(sigma, noise.sigma_range)
# update linked parameters in model
update!(estimates, sampler.paralinks)
# update logp
logp_next = noise.logpdf(meas, model_signals(estimates, protocol), sigma)
# acception ratio
if rand(Float64) < min(1, exp.(logp_next - logp_start))
move = 1
logp_start = copy(logp_next)
else
move = 0
# move estimates back to previous location
decrement!(estimates, pertubation)
update!(estimates, sampler.paralinks)
sigma -= pertubations["sigma"][i]
end
else
move = 0
# move next back to current location
decrement!(estimates, pertubation)
sigma -= pertubations["sigma"][i]
end
record_chain!(chain, estimates, sampler.params, i, move, sigma, logp_start)
end
#update model object as the mean values of selected samples
update!(
estimates,
Tuple(
para => mean(chain[para][(sampler.burnin+1):(sampler.thinning):end]) for
para in sampler.params
),
)
update!(estimates, sampler.paralinks)
return nothing
end
## testing: mcmc with given noise level sigma
function mcmc!(
estimates::BiophysicalModel,
meas::Vector{Float64},
protocol::Protocol,
sampler::Sampler,
sigma::Float64,
rng::Int64=1,
)
Random.seed!(rng)
# create chain and pertubations
chain = create_chain(sampler, "dict")
pertubations = draw_samples(sampler, "dict")
# get logp_start from the start model and sigma
logp_start = noise.logpdf(meas, model_signals(estimates, protocol), sigma)
@inbounds for i in 1:(sampler.nsamples::Int)
# get current pertubation
pertubation = Tuple(para => pertubations[para][i] for para in sampler.params)
# get the next sample location and check if it is within prior ranges
outliers = increment!(estimates, pertubation, sampler.prior_range)
if iszero(outliers)
# update linked parameters in model
update!(estimates, sampler.paralinks)
# update logp
logp_next = noise.logpdf(meas, model_signals(estimates, protocol), sigma)
# acception ratio
if rand(Float64) < min(1, exp(logp_next - logp_start))
move = 1
logp_start = copy(logp_next)
else
move = 0
# move estimates back to previous location
decrement!(estimates, pertubation)
update!(estimates, sampler.paralinks)
end
else
move = 0
# move next back to current location
decrement!(estimates, pertubation)
end
record_chain!(chain, estimates, sampler.params, i, move, sigma, logp_start)
end
#update model object as the mean values of selected samples
update!(
estimates,
Tuple(
para => mean(chain[para][(sampler.burnin+1):(sampler.thinning):end]) for
para in sampler.params
),
)
update!(estimates, sampler.paralinks)
return chain
end
function record_chain!(
chain::Dict{String,Vector{Any}},
estimates::BiophysicalModel,
params::Tuple{Vararg{String}},
move::Int64,
sigma::Float64,
logp::Float64,
)
# record estimates to chain
for para in params
push!(chain[para], getsubfield(estimates, para))
end
push!(chain["sigma"], sigma)
push!(chain["logp"], logp)
push!(chain["move"], move)
return nothing
end
function record_chain!(
chain::Dict{Any,Any},
estimates::BiophysicalModel,
params::Tuple{Vararg{String}},
i::Int64,
move::Int64,
sigma::Float64,
logp::Float64,
)
for para in params
chain[para][i] = getsubfield(estimates, para)
end
chain["sigma"][i] = sigma
chain["logp"][i] = logp
chain["move"][i] = move
return nothing
end
function record_chain!(
chain::Vector{Any},
estimates::BiophysicalModel,
params::Tuple{Vararg{String}},
i::Int64,
move::Int64,
sigma::Float64,
logp::Float64,
)
for (j, para) in enumerate(params)
chain[j][i] = getsubfield(estimates, para)
end
chain[end - 2][i] = sigma
chain[end - 1][i] = logp
chain[end][i] = move
return nothing
end
"""
update!(model::BiophysicalModel, fields::Tuple{Vararg{Pair{String, <:Any}}})
update fields and subfields of a model object using
(1) given pairs containing the fieldnames and values to update; can be values or parameter links
```julia-repl
julia> update!(ExCaliber(),("axon.da" => 3e-6, "axon.d0" => "axon.dpara"))
```
(2) another model object and fieldnames
```julia-repl
julia> update!(model_target, model_source, fieldnames)
```
"""
# update parameter and values pairs; allow mixed type in specification
function update!(model::BiophysicalModel, allfields::Tuple{Vararg{Pair{String,<:Any}}})
for pair in allfields
update!(model, pair)
end
return nothing
end
function update!(model::BiophysicalModel, pair::Pair{String,Float64})
# find the compartment and corresponding field to update
ind = findfirst('.', pair[1])
if !isnothing(ind)
compname = Symbol(pair[1][1:(ind - 1)])
subfield = Symbol(pair[1][(ind + 1):end])
# update subfield
comp = getfield(model, compname)
setfield!(comp, subfield, pair[2])
else
setfield!(model, Symbol(pair[1]), pair[2])
end
return nothing
end
# update only fracs
function update!(model::BiophysicalModel, pair::Pair{String,Vector{Float64}})
setfield!(model, Symbol(pair[1]), pair[2])
return nothing
end
# update parameters using given parameter links
function update!(model::BiophysicalModel, pair::Pair{String,String})
# find the compartment and corresponding field to update
compname, field = findsubfield(pair[1])
# find the value from given parameter link
compname2, field2 = findsubfield(pair[2])
value = getfield(getfield(model, compname2), field2)
# update subfield
comp = getfield(model, compname)
setfield!(comp, field, value)
return nothing
end
# Updating a model object using values from another object
function update!(
model::BiophysicalModel, source::BiophysicalModel, fields::Tuple{Vararg{String}}
)
for field in fields
value = getsubfield(source, field)
update!(model, field => value)
end
return nothing
end
"""
getsubfiled(model, fieldname)
Get field/subfield values from a model object that can be used to update fields
"""
function getsubfield(model::BiophysicalModel, field::String)
# find the compartment and corresponding field to update
ind = findfirst('.', field)
if !isnothing(ind)
compname = Symbol(field[1:(ind - 1)])
subfield = Symbol(field[(ind + 1):end])
# update subfield
value = getfield(getfield(model, compname), subfield)
else
value = getfield(model, Symbol(field))
end
return value
end
function findsubfield(field::String)
ind = findfirst('.', field)
compname = Symbol(field[1:(ind - 1)])
subfield = Symbol(field[(ind + 1):end])
return compname, subfield
end
"""
decrement!(model::BiophysicalModel, fields::Tuple{Vararg{Pair{String, <:Any}}})
Move estimates back to previous location before current pertubation. No bounds checking.
"""
function decrement!(model::BiophysicalModel, allfields::Tuple{Vararg{Pair{String,<:Any}}})
for pair in allfields
decrement!(model, pair)
end
return nothing
end
# Decrement fields
function decrement!(model::BiophysicalModel, pair::Pair{String,Float64})
# find the compartment and corresponding field to update
ind = findfirst('.', pair[1])
if !isnothing(ind)
# update subfield
compname = Symbol(pair[1][1:(ind - 1)])
field = Symbol(pair[1][(ind + 1):end])
comp = getfield(model, compname)
value = getfield(comp, field) - pair[2]
setfield!(comp, field, value)
else
#update field
field = Symbol(pair[1])
value = getfield(model, field) - pair[2]
setfield!(model, field, value)
end
return nothing
end
function decrement!(model::BiophysicalModel, pair::Pair{String,Vector{Float64}})
field = Symbol(pair[1])
value = getfield(model, field) .- pair[2]
setfield!(model, field, value)
return nothing
end
"""
increment!(
model::BiophysicalModel,
pairs::Tuple{Vararg{Pair{String, <:Any}}},
ranges::Tuple{Vararg{Tuple{Float64, Float64}}}
)
Increment model estimates in place and return outliers by checking prior ranges.
`model`: a biophysical model;
`pairs`: paras of fields/subfiedls and values to add; fieldname => value2add;
`ranges`: prior range.
"""
function increment!(
model::BiophysicalModel,
allfields::Tuple{Vararg{Pair{String,<:Any}}},
bounds::Tuple{Vararg{Tuple{Float64,Float64}}},
)
outliers = 0
for (i, pair) in enumerate(allfields)
outliers += increment!(model, pair, bounds[i])
end
return outliers
end
# for fraction vectors
function increment!(
model::BiophysicalModel,
pair::Pair{String,Vector{Float64}},
bounds::Tuple{Float64,Float64},
)
field = Symbol(pair[1])
value = getfield(model, field) .+ pair[2]
setfield!(model, field, value)
return outlier_checking(value, bounds)
end
# for other fields
function increment!(
model::BiophysicalModel, pair::Pair{String,Float64}, bounds::Tuple{Float64,Float64}
)
# find the compartment and corresponding field to updates
ind = findfirst('.', pair[1])
if !isnothing(ind)
compname = Symbol(pair[1][1:(ind - 1)])
field = Symbol(pair[1][(ind + 1):end])
# get updated subfield value
comp = getfield(model, compname)
value = getfield(comp, field) + pair[2]
setfield!(comp, field, value)
return outlier_checking(value, bounds)
else
field = Symbol(pair[1])
value = getfield(model, field) + pair[2]
setfield!(model, field, value)
return outlier_checking(value, bounds)
end
end
"""
outlier_checking(value,(lowerbound,upperbound))
Check if a value is an outlier given a range (lowerbound,upperbound); return true if considered outlier.
When `value` is a vector which means it represents fractions, the method checks if any elements
or the sum of all the elements contain an outlier; return the number of outliers encounted.
"""
function outlier_checking(value::Float64, bounds::Tuple{Float64,Float64})
return (value < bounds[1] || value > bounds[2])
end
function outlier_checking(fracs::Vector{Float64}, bounds::Tuple{Float64,Float64})
s = sum(fracs)
outliers = outlier_checking(s, bounds)
for i in eachindex(fracs)
outliers += outlier_checking(fracs[i], bounds)
end
return outliers
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 14018 |
using ProgressMeter
using Flux, Distributions, Random, Statistics
export NetworkArg,
TrainingArg,
prepare_training,
create_mlp,
generate_samples,
train_loop!,
test,
losses_rmse,
losses_corr,
losses_rmse_kl,
losses_rmse_corr
"""
NetworkArg(
model::BiophysicalModel
protocol::Protocol
params::Tuple{Vararg{String}}
prior_range::Tuple{Vararg{Tuple{Float64,Float64}}} # range for priors
prior_dist::Tuple{Vararg{<:Any}}
paralinks::Tuple{Vararg{Pair{String,<:String}}} = ()
noise_type::String = "Gaussian" # "Rician"
sigma_range::Tuple{Float64, Float64}
sigma_dist::Distribution
nsamples::Int64
nin::Int64
nout::Int64
hidden_layers::Tuple{Vararg{Int64}}
dropoutp::Union{<:AbstractFloat, Tuple{Vararg{<:AbstractFloat}}}
actf::Function
)
Return a `NetworkArg` object with necessary parameters to construct a neural network model
and generate training samples for specifc biophysical model. A test network architecture and training samples can be automaticlly determined from the modelling task by using function
NetworkArg(model, protocol, params, prior_range, prior_dist, paralinks, noisetype, sigma_range, sigma_dist)
"""
Base.@kwdef struct NetworkArg
model::BiophysicalModel
protocol::Protocol
params::Tuple{Vararg{String}}
prior_range::Tuple{Vararg{Tuple{Float64,Float64}}} # range for priors
prior_dist::Tuple{Vararg{<:Any}}
paralinks::Tuple{Vararg{Pair{String,<:String}}} = ()
noise_type::String = "Gaussian" # "Rician"
sigma_range::Tuple{Float64, Float64}
sigma_dist::Distribution
nsamples::Int64
nin::Int64
nout::Int64
hidden_layers::Tuple{Vararg{Int64}}
dropoutp::Union{<:AbstractFloat, Tuple{Vararg{<:AbstractFloat}}}
actf::Function = relu6 # activate function for output layer
end
"""
TrainingArg(
batchsize::Int64
lossf::Function
lr::Float64
epoch::Int64
tv_split::Float64
patience::Tuple{Int64,Int64}
)
Return `TrainingArg` Type object with fields related to how network will be trained.
batch size; loss function; learning rate; number of epoches; validation/training data split;
patience for train loss plateau, patience for validation loss to increase.
Patiences are currently not applied when training and validating on generated training samples from uniform parameter distributions,
therefore training will stop when reaching the number of epoches.
The patience parameter will be considered in the future when training with real data or generated data with other distributions.
"""
Base.@kwdef struct TrainingArg
batchsize::Int64 = 128
lossf::Function = Flux.Losses.mse
lr::Float64 = 0.001
epoch::Int64 = 100
tv_split::Float64 = 0.2
patience::Tuple{Int64,Int64} = (10, 30)
end
"""
NetworkArg(model, protocol,params,paralinks,tissuetype,sigma,noise_type,dropoutp=0.2)
Use the inputs related to biophysical models to determine network architecture and number of training samples for test
return a full defined NetworkArg struct
Reference for adjusting the number of training samples:
Shwartz-Ziv, R., Goldblum, M., Bansal, A., Bruss, C.B., LeCun, Y., & Wilson, A.G. (2024). Just How Flexible are Neural Networks in Practice?
(Easier task and smaller MLPs have higher effective model complexity (can fit more training samples than network parameters;
for more complex tasks and larger MLPs, the number of training samples can be set as similar to the number of network parameters to improve training efficiency)
"""
function NetworkArg(
model::BiophysicalModel,
protocol::Protocol,
params::Tuple{Vararg{String}},
prior_range::Tuple{Vararg{Tuple{Float64,Float64}}},
prior_dist::Tuple{Vararg{<:Any}},
paralinks::Tuple{Vararg{Pair{String,<:String}}},
noise_type::String,
sigma_range::Tuple{Float64, Float64},
sigma_dist::Distribution,
dropoutp=0.2,
actf = relu6,
)
nin = length(protocol.bval)
nout = 0
for para in params
nout += length(getsubfield(model, para))
end
hidden_layers = (nin * 4, nin * nout, nout * 8)
num = (nin, hidden_layers..., nout)
# the number of trainable parameters in the network
npar = 0
for i in 1:(length(num) - 1)
npar += (num[i] + 1) * num[i + 1]
end
# adjust "50"
nsamples = npar * 50
arg = NetworkArg(
model,
protocol,
params,
prior_range,
prior_dist,
paralinks,
noise_type,
sigma_range,
sigma_dist,
nsamples,
nin,
nout,
hidden_layers,
dropoutp,
actf,
)
return arg
end
"""
prepare_training(arg::NetworkArg)
Return (`mlp`, `inputs`, `labels`, `gt`); `mlp` is the multi-layer perceptron network model for the biophysical model;
`inputs` and `labels` are arrays of signals and scaled tissue parameters used for supervised training; and
`gt` is a dict containing the ground truth tissue parameters without applying scaling. Scaling is applied in the
training labels to ensure different tissue parameters are roughly in the same range as they are optimized together.
"""
function prepare_training(arg::NetworkArg, rng_seed::Int)
mlp = create_mlp(arg.nin, arg.nout, arg.hidden_layers, arg.dropoutp, arg.actf)
(inputs, labels, gt) = generate_samples(
arg.model,
arg.protocol,
arg.params,
arg.prior_range,
arg.prior_dist,
arg.nsamples,
arg.paralinks,
arg.sigma_range,
arg.sigma_dist,
arg.noise_type,
rng_seed,
)
return mlp, inputs, labels, gt
end
"""
create_mlp(
ninput::Int,
noutput::Int,
hiddenlayers::Tuple{Vararg{Int}},
dropoutp::Union{<:AbstractFloat,Tuple{Vararg{<:AbstractFloat}}}
)
Return a `mlp` with `ninput`/`noutput` as the number of input/output channels, and number of units in each layer specified in `hiddenlayers`;
'dropoutp' contains the dropout probalibities for dropout layers; it can be a single value (one dropout layer before output) or same length as the hidden layers
"""
function create_mlp(
ninput::Int, noutput::Int, hiddenlayers::Tuple{Vararg{Int}}, dropoutp::Union{<:AbstractFloat,Tuple{Vararg{<:AbstractFloat}}}, out_actf::Function=relu6,
)
num = (ninput, hiddenlayers...)
layers_dense = [Dense(num[i] => num[i + 1], relu) for i in 1:(length(num) - 1)]
if length(dropoutp) == 1
mlp = Chain(layers_dense..., Dropout(Float32.(dropoutp)),
Dense(hiddenlayers[end] => noutput, out_actf))
elseif length(dropoutp)==length(hiddenlayers)
layers_dropout = [Dropout(Float32.(dropoutp[i])) for i in eachindex(dropoutp)]
layers = Any[]
for i in eachindex(dropoutp)
push!(layers, layers_dense[i])
push!(layers, layers_dropout[i])
end
mlp = Chain(layers...,
Dense(hiddenlayers[end] => noutput, out_actf))
else
error("Numbers of dropout and hidden layer don't match")
end
return mlp
end
"""
generate_samples(
model::BiophysicalModel,
protocol::Protocol,
params::Tuple{Vararg{String}},
prior_range::Tuple{Vararg{Tuple{Float64,Float64}}},
prior_dist::Tuple{Vararg{<:Any}},
nsample::Int,
paralinks::Tuple{Vararg{Pair{String}}},
sigma_range::Tuple{Float64, Float64},
sigma::Distribution,
noise_type::String="Gaussian",
rng_seed,
)
Generate and return training samples for a model using given priors of tissue parameters
and specified noise model (`"Gaussian"` or `"Rician"`) and noise level.
"""
function generate_samples(
model::BiophysicalModel,
protocol::Protocol,
params::Tuple{Vararg{String}},
prior_range::Tuple{Vararg{Tuple{Float64,Float64}}},
prior_dist::Tuple{Vararg{<:Any}},
nsample::Int,
paralinks::Tuple{Vararg{Pair{String}}},
sigma_range::Tuple{Float64, Float64},
sigma_dist::Distribution,
noise_type::String="Gaussian",
rng_seed::Int=1,
)
params_labels = []
params_gt = Dict()
Random.seed!(rng_seed)
for (p, para) in enumerate(params)
if !hasfield(typeof(model), Symbol(para))
if isnothing(prior_dist[p])
vecs =
prior_range[p][1] .+
(prior_range[p][2] - prior_range[p][1]) .*
rand(Float64, nsample)
else
vecs =
rand(truncated(prior_dist[p],
prior_range[p][1], prior_range[p][2]),
nsample)
end
push!(
params_labels,
(vecs ./ prior_range[p][2])',
)
push!(params_gt, para => vecs)
elseif para == "fracs"
vecs = rand(prior_dist[p], nsample)
push!(params_labels, vecs[1:(end - 1), :])
if model.fracs isa Vector
vecs = [vecs[1:(end - 1), i] for i in 1:nsample]
else
vecs = [vecs[1, i] for i in 1:nsample]
end
push!(params_gt, para => vecs)
end
end
params_labels = reduce(vcat, params_labels)
# simulate signals
nvol = length(protocol.bval)
signals = zeros(nvol, nsample)
for i in 1:nsample
update!(model, Tuple(para => params_gt[para][i] for para in params))
update!(model, paralinks)
signals[:, i] = model_signals(model, protocol)
end
# add gaussian noise to get training inputs
noise_level = rand(truncated(sigma_dist, sigma_range[1], sigma_range[2]), nsample)
if (noise_type == "Gaussian") | (noise_type == "gaussian")
for i in 1:nsample
signals[:, i] .= signals[:,i] .+ rand(Normal(0, noise_level[i]), nvol)
signals[:,i] = signals[:,i] ./ signals[1,i]
end
elseif (noise_type == "Rician") | (noise_type == "rician")
for i in 1:nsample
signals[:,i] .=
sqrt.(
(signals[:,i] .+ rand(Normal(0, noise_level[i]), nvol)) .^ 2.0 .+
rand(Normal(0, noise_level[i]), nvol) .^ 2.0
)
signals[:,i] = signals[:,i] ./ signals[1,i]
end
else
error("Noise type not indentified")
end
return Float32.(signals), Float32.(params_labels), params_gt
end
"""
train_loop!(
mlp::Chain,
arg::TrainingArg,
inputs::Array{Float64,2},
labels::Array{Float64,2}
)
Train and update the `mlp` and return a Dict of training logs with train loss, training data loss and validation data loss for each epoch.
"""
function train_loop!(
mlp::Chain{T}, arg::TrainingArg, inputs::Array{<:AbstractFloat,2}, labels::Array{<:AbstractFloat,2}
) where {T}
opt_state = Flux.setup(Adam(arg.lr), mlp)
tv_index = floor(Int64, size(inputs, 2) * arg.tv_split)
val_set = Flux.DataLoader(
(@views inputs[:, 1:tv_index], @views labels[:, 1:tv_index]);
batchsize=arg.batchsize,
)
train_set = Flux.DataLoader(
(@views inputs[:, (tv_index + 1):end], @views labels[:, (tv_index + 1):end]);
batchsize=arg.batchsize,
)
# function to calculate validation/training data loss
loss(mlp, x, y) = arg.lossf(mlp(x), y)
data_loss(mlp, dataset) = mean(loss(mlp, data...) for data in dataset)
train_log = Dict("train_loss" => [], "val_data_loss" => [], "train_data_loss" => [])
print("Training ...")
@showprogress for epoch in 1:(arg.epoch)
losses = 0.0
for (i, data) in enumerate(train_set)
input, label = data
val, grads = Flux.withgradient(mlp) do m
# Any code inside here is differentiated.
result = m(input)
arg.lossf(result, label)
end
# add batch loss
losses += val
# Detect loss of Inf or NaN. Print a warning, and then skip update!
if !isfinite(val)
@warn "loss is $val on item $i" epoch
continue
end
Flux.update!(opt_state, mlp, grads[1])
end
#println("Epoch #" * string(epoch) * "; training loss: " * string(losses / length(train_set)))
# Save the epoch train/val loss to log
push!(train_log["train_loss"], losses / length(train_set))
push!(train_log["val_data_loss"], data_loss(mlp, val_set))
push!(train_log["train_data_loss"], data_loss(mlp, train_set))
end
return train_log
end
"""
test(mlp::Chain, data::Array{<:AbstractFloat,2}, ntest)
Return mean and standard deviation of estimations by applying a trained `mlp` to test data for `ntest` times
with dropout layer on.
"""
function test(mlp::Chain{T}, data::Array{<:AbstractFloat,2}, ntest) where {T}
est = []
est_std = []
Flux.trainmode!(mlp)
for i in 1:size(data, 2)
test = mlp(data[:, i])
for j in 1:(ntest - 1)
test = hcat(test, mlp(data[:, i]))
end
push!(est, dropdims(mean(test; dims=2); dims=2))
push!(est_std, dropdims(std(test; dims=2); dims=2))
end
return est, est_std
end
"""
RMSE loss
"""
function losses_rmse(y, yy)
return sqrt.(Flux.Losses.mse(y, yy))
end
# test loss
function losses_corr(y,yy)
n=size(y,1)
corr = (n*sum(y.*yy,dims=1) - sum(y,dims=1).*sum(yy,dims=1))./
sqrt.((n*sum(y.^2,dims=1)-sum(y,dims=1).^2).*(n*sum(yy.^2,dims=1)-sum(yy,dims=1).^2))
return -mean(corr)
end
function losses_rmse_kl(y, yy)
return 0.8*sqrt.(Flux.Losses.mse(y, yy)) + 0.2*Flux.Losses.kldivergence(y,yy)
end
function losses_rmse_corr(y, yy)
return 0.8*losses_rmse(y, yy) + 0.2*losses_corr(y,yy)
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 11472 | # Definitions of biophysical models.
#
# This script builds model structs with fields of tissue compartments and signal fractions,
# and forward functions inferencing signals from the model struct and imaging protocol.
#
# quickly fetch literature models
# you can also add your models with desired combinations of compartments here
export model_signals,
SANDI,
SANDIdot,
MTE_SANDI,
ExCaliber,
MTE_SMT,
print_model,
BiophysicalModel,
ExCaliber_beta
#model_signals!
"""
All models in this page belong to the BiophysicalModel Type. You can also build your models with desired combinations of compartments using a similar syntax.
In each model, all compartmental parameters can be considered "free parameters" and sampled using MCMC.
This is designed to offer maximum flexibility in adjusting model assumptions, but it doesn't guarantee reliable estimation of all parameters.
It's common that we need to fix or link some tissue parameters based on our data measurement protocols and our tissue parameters of interest.
Parameter fixing and linking can be achieved by settings in MCMC sampler in the estimator module.
"""
abstract type BiophysicalModel end
"""
SANDI(
soma::Sphere,
neurite::Stick,
extra::Iso,
fracs::Vector{Float64}
)
The soma and neurite density imaging (SANDI) model uses a sphere compartment to model the cell soma,
a stick compartment to model the neurite and an isotropic diffusion compartment for the extra-cellular space;
It includes all the tissue parameters in each compartment and a `fracs` vector representing the fraction of
intra-soma signal and intra-neurite signal (the extra-cellular signal fraction is 1-sum(fracs)).
For SANDI model, ignore the field of `t2` in all compartments and set them to 0.
# Reference
Palombo, M., Ianus, A., Guerreri, M., Nunes, D., Alexander, D.C., Shemesh, N., Zhang, H., 2020. SANDI: A compartment-based model for non-invasive apparent soma and neurite imaging by diffusion MRI. Neuroimage 215. https://doi.org/10.1016/j.neuroimage.2020.116835
"""
Base.@kwdef mutable struct SANDI <: BiophysicalModel
soma::Sphere = Sphere(; diff=3.0e-9)
neurite::Stick = Stick()
extra::Iso = Iso()
fracs::Vector{Float64} = [0.4, 0.3]
end
"""
MTE_SANDI(
soma::Sphere
neurite::Stick
extra::Iso
fracs::Vector{Float64}
S0norm::Float64
)
For Multi-echo-SANDI (MTE-SANDI) model, consider the `t2` values in all compartments,
and the fractions estimated will be non-T2-weighted compartment fractions in comparison to the model mentioned above.
`S0norm` is the relaxation-weighting free signal from all compartments S(b=0,t=0) normalised by S(b=0,t=TEmin).
# Reference
Gong, T., Tax, C.M., Mancini, M., Jones, D.K., Zhang, H., Palombo, M., 2023. Multi-TE SANDI: Quantifying compartmental T2 relaxation times in the grey matter. Toronto.
"""
Base.@kwdef mutable struct MTE_SANDI <: BiophysicalModel
soma::Sphere = Sphere(; diff=3.0e-9)
neurite::Stick = Stick()
extra::Iso = Iso()
fracs::Vector{Float64} = [0.4, 0.3]
end
"""
SANDIdot(
soma::Sphere
neurite::Stick
extra::Iso
dot::Iso
fracs::Vector{Float64}
)
SANDIdot model includes additionally a dot compartment for SANDI model; the dot compartment is considered as immobile water and is more commonly seen in ex vivo imaging.
For SANDIdot model, ignore the field of t2 in all compartments and set them to 0. The fraction vector represents fractions of the soma,
neurite and dot with the fraction of extra being 1-sum(fracs).
# Reference
Alexander, D.C., Hubbard, P.L., Hall, M.G., Moore, E.A., Ptito, M., Parker, G.J.M., Dyrby, T.B., 2010. Orientationally invariant indices of axon diameter and density from diffusion MRI. Neuroimage 52, 1374–1389. https://doi.org/10.1016/j.neuroimage.2010.05.043
Panagiotaki, E., Schneider, T., Siow, B., Hall, M.G., Lythgoe, M.F., Alexander, D.C., 2012. Compartment models of the diffusion MR signal in brain white matter: A taxonomy and comparison. Neuroimage 59, 2241–2254.
Palombo, M., Ianus, A., Guerreri, M., Nunes, D., Alexander, D.C., Shemesh, N., Zhang, H., 2020. SANDI: A compartment-based model for non-invasive apparent soma and neurite imaging by diffusion MRI. Neuroimage 215. https://doi.org/10.1016/j.neuroimage.2020.116835
"""
Base.@kwdef mutable struct SANDIdot <: BiophysicalModel
soma::Sphere = Sphere(; diff=2.0e-9)
neurite::Stick = Stick(; dpara=0.6e-9)
extra::Iso = Iso(; diff=0.8e-9)
dot::Iso = Iso(; diff=0.0)
fracs::Vector{Float64} = [0.5, 0.3, 0.1]
end
"""
ExCaliber(
axon::Cylinder,
extra::Zeppelin,
dot::Iso,
fracs::Vector{Float64}
)
ExCaliber is a multi-compartment model for estimating axon diameter. It can be used for ex vivo imaging when the diffusivity in the ISO compartment is set to 0 (dot compatment),
and for in vivo imaging if the diffusivity of the ISO compartment is set to free water in tissue (CSF compartment).
# Reference
Fan, Q., Nummenmaa, A., Witzel, T., Ohringer, N., Tian, Q., Setsompop, K., ... & Huang, S. Y. (2020). Axon diameter index estimation independent of fiber orientation distribution using high-gradient diffusion MRI. Neuroimage, 222, 117197.
Gong, T., Maffei, C., Dann, E., Lee, H.-H., Lee Hansol, Huang, S., Suzanne, H., Yendiki, A., 2024. Imaging the relationship of axon diameter and myelination in macaque and human brain, in: ISMRM.
"""
Base.@kwdef mutable struct ExCaliber <: BiophysicalModel
axon::Cylinder = Cylinder()
extra::Zeppelin = Zeppelin()
dot::Iso = Iso(; diff=0.0)
fracs::Vector{Float64} = [0.7, 0.1]
end
# test model including extra CSF compartment
Base.@kwdef mutable struct ExCaliber_beta <: BiophysicalModel
axon::Cylinder = Cylinder()
extra::Zeppelin = Zeppelin()
csf::Iso = Iso(; diff=2.0e-9)
dot::Iso = Iso(; diff=0.0)
fracs::Vector{Float64} = [0.7, 0.1, 0.1]
end
"""
MTE_SMT(
axon::Stick = Stick()
extra::Zeppelin = Zeppelin()
fracs::Float64 = 0.5
)
This is a model using multi-TE spherical mean technique for lower b-value in vivo imaging. Compartmental T2s are considered.
There is not a specific reference for this model yet, but you can refer to previous work related to this topic:
Kaden, E., Kruggel, F., Alexander, D.C., 2016. Quantitative mapping of the per-axon diffusion coefficients in brain white matter. Magn Reson Med 75, 1752–1763. https://doi.org/10.1002/MRM.25734
Kaden, E., Kelm, N. D., Carson, R. P., Does, M. D., & Alexander, D. C. (2016). Multi-compartment microscopic diffusion imaging. NeuroImage, 139, 346-359.
Veraart, J., Novikov, D.S., Fieremans, E., 2017. TE dependent Diffusion Imaging (TEdDI) distinguishes between compartmental T 2 relaxation times. https://doi.org/10.1016/j.neuroimage.2017.09.030
Gong, T., Tong, Q., He, H., Sun, Y., Zhong, J., Zhang, H., 2020. MTE-NODDI: Multi-TE NODDI for disentangling non-T2-weighted signal fractions from compartment-specific T2 relaxation times. Neuroimage 217. https://doi.org/10.1016/j.neuroimage.2020.116906
"""
Base.@kwdef mutable struct MTE_SMT <: BiophysicalModel
axon::Stick = Stick()
extra::Zeppelin = Zeppelin()
fracs::Float64 = 0.5
end
"""
model_signals(model::BiophysicalModel,prot::Protocol[,links])
Reture predicted model signals from BiophysicalModel `model` and imaging protocol 'prot'.
`links` is a optional argument that specify parameter links in the model.
"""
function model_signals(excaliber::ExCaliber, prot::Protocol)
fextra = 1 - sum(excaliber.fracs)
signals =
excaliber.fracs[1] .* compartment_signals(excaliber.axon, prot) .+
fextra .* compartment_signals(excaliber.extra, prot) .+ excaliber.fracs[2]
return signals
end
function model_signals(excaliber::ExCaliber_beta, prot::Protocol)
fextra = 1 - sum(excaliber.fracs)
signals =
excaliber.fracs[1] .* compartment_signals(excaliber.axon, prot) .+
fextra .* compartment_signals(excaliber.extra, prot) .+
excaliber.fracs[2] .* compartment_signals(excaliber.csf, prot) .+ excaliber.fracs[3]
return signals
end
function model_signals(sandi::SANDIdot, prot::Protocol)
fextra = 1.0 - sum(sandi.fracs)
signals =
sandi.fracs[1] .* compartment_signals(sandi.soma, prot) .+
sandi.fracs[2] .* compartment_signals(sandi.neurite, prot) .+
fextra .* compartment_signals(sandi.extra, prot) .+ sandi.fracs[3]
return signals
end
function model_signals(sandi::SANDI, prot::Protocol)
fextra = 1.0 - sum(sandi.fracs)
signals =
sandi.fracs[1] .* compartment_signals(sandi.soma, prot) .+
sandi.fracs[2] .* compartment_signals(sandi.neurite, prot) .+
fextra .* compartment_signals(sandi.extra, prot)
return signals
end
function model_signals(sandi::MTE_SANDI, prot::Protocol)
fextra = 1.0 - sum(sandi.fracs)
signals =
(
sandi.fracs[1] .* compartment_signals(sandi.soma, prot) .+
sandi.fracs[2] .* compartment_signals(sandi.neurite, prot) .+
fextra .* compartment_signals(sandi.extra, prot)
)
return signals ./ signals[1]
end
function model_signals(model::MTE_SMT, prot::Protocol)
signals =
(
model.fracs .* compartment_signals(model.axon, prot) .+
(1.0 .- model.fracs) .* compartment_signals(model.extra, prot)
)
return signals ./ signals[1]
end
"""
print_model(model::BiophysicalModel)
Helper function to check all tissue parameters in a model
"""
function print_model(model::BiophysicalModel)
println(typeof(model), ":")
for field in fieldnames(typeof(model))
comp = getfield(model, field)
subfield = fieldnames(typeof(comp))
println(field, subfield)
end
end
##########################
# dev
# test mutating implementation
function model_signals!(signals::Vector{Float64}, excaliber::ExCaliber, prot::Protocol)
signals .= 0.0
signals_com = similar(signals)
fextra = 1 - sum(excaliber.fracs)
compartment_signals!(signals_com, excaliber.axon, prot)
signals .= signals .+ excaliber.fracs[1] .* signals_com
compartment_signals!(signals_com, excaliber.extra, prot)
signals .= signals .+ fextra .* signals_com
compartment_signals!(signals_com, excaliber.csf, prot)
signals .= signals .+ excaliber.fracs[2] .* signals_com
signals .= signals .+ excaliber.fracs[3]
return nothing
end
# test mutating implementation
function model_signals!(
signals::Vector{Float64},
signals_com::Vector{Float64},
excaliber::ExCaliber,
prot::Protocol,
)
signals .= 0.0
fextra = 1 - sum(excaliber.fracs)
compartment_signals!(signals_com, excaliber.axon, prot)
signals .= signals .+ excaliber.fracs[1] .* signals_com
compartment_signals!(signals_com, excaliber.extra, prot)
signals .= signals .+ fextra .* signals_com
compartment_signals!(signals_com, excaliber.csf, prot)
signals .= signals .+ excaliber.fracs[2] .* signals_com
signals .= signals .+ excaliber.fracs[3]
return nothing
end
# update parameter links and get model signals
function model_signals(
model::BiophysicalModel, prot::Protocol, links::Tuple{Vararg{Pair{String,String}}}
)
PMI.update!(model, links)
return model_signals(model, prot)
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 10593 | using ProgressMeter
export pre_allocate, empty_chain!, create_chain, threading
"""
This method runs multi-threads MCMC estimation on dMRI data using a specified biophysical model, calls the voxel threading
method and save estimated parameters as nifti files. `savedir` includes both output path and file name prefix.
Two-stage MCMC sampling methods are run if provided sampler is a Tuple of two samplers, where it will sample all the unknown parameters
using the first sampler then sample target tissue parameters in the second sampler while fixing the rest parameters to posterior means in the first MCMC.
threading(
model_start::BiophysicalModel,
sampler::Union{Sampler,Tuple{Sampler,Sampler}},
dmri::MRI,
mask::MRI,
protocol::Protocol,
noise_model::Noisemodel,
savedir::String,
)
Methods that return mean and standard deviation of estimations from measurements array of size [Nmeas, Nvoxels] using single-stage or two-stage MCMC.
threading(
model_start::BiophysicalModel,
sampler::Sampler,
measurements::Array{Float64,2},
protocol::Protocol,
noise_model::Noisemodel,
)
threading(
model_start::BiophysicalModel,
sampler::Tuple{Sampler,Sampler},
measurements::Array{Float64,2},
protocol::Protocol,
noise_model::Noisemodel,
)
"""
function threading(
model_start::BiophysicalModel,
sampler::Union{Sampler,Tuple{Sampler,Sampler}},
dmri::MRI,
mask::MRI,
protocol::Protocol,
noise_model::Noisemodel,
datadir::String,
rng::Int64=1,
)
indexing = dropdims(mask.vol; dims=4)
# put measurments in first dimension for faster iteration
meas = Float64.(permutedims(dmri.vol[indexing .> 0, :], (2, 1)))
# multi-threads processing of voxels within tissue mask
Random.seed!(rng)
est, est_std = threading(model_start, sampler, meas, protocol, noise_model)
sampler isa Tuple ? params = sampler[1].params : params = sampler.params
print("saving nifti files...")
for (ip, para) in enumerate(params)
if est[ip][1] isa Vector
mri = MRI(mask, length(est[ip][1]), Float64)
mri.vol[indexing .> 0, :] .= reduce(hcat, est[ip])'
mri_write(mri, datadir * para * ".mean.nii.gz")
mri.vol[indexing .> 0, :] .= reduce(hcat, est_std[ip])'
mri_write(mri, datadir * para * ".std.nii.gz")
else
mri = MRI(mask, 1, Float64)
mri.vol[indexing .> 0] .= est[ip]
mri_write(mri, datadir * para * ".mean.nii.gz")
mri.vol[indexing .> 0] .= est_std[ip]
mri_write(mri, datadir * para * ".std.nii.gz")
end
end
print("Complete!")
return nothing
end
# threading voxels; this can be used alone for real or simulated data without reading data from nifti files
function threading(
model_start::BiophysicalModel,
sampler::Sampler,
meas::Array{Float64,2},
protocol::Protocol,
noise_model::Noisemodel,
)
datasize = size(meas)
pertubations = draw_samples(sampler, noise_model, "vec")
(measurements, estimates, chains, est, est_std) = pre_allocate(
model_start, sampler, datasize
)
print("MCMC sampling...")
@showprogress Threads.@threads for iv in 1:(datasize[2]::Int)
# for voxels in the same thread, use the allocated space repeatedly
td = Threads.threadid()
measurements[td] .= meas[:, iv]
# ignore voxels when normalized signals containing NaN or values larger than 1
sum(measurements[td]) == NaN && continue
maximum(measurements[td]) > 1 && continue
# if want to use the same starting point for all voxels, add these two steps
update!(estimates[td], model_start, sampler.params)
update!(estimates[td], sampler.paralinks)
mcmc!(chains[td], estimates[td], measurements[td], protocol, sampler, pertubations)
for ip in 1:length(sampler.params)
est[ip][iv] = mean(
chains[td][ip][(sampler.burnin+1):(sampler.thinning):(sampler.nsamples)]
)
est_std[ip][iv] = std(
chains[td][ip][(sampler.burnin+1):(sampler.thinning):(sampler.nsamples)]
)
end
end
return est, est_std
end
# voxel threading functions for two-stage MCMC sampling where you sample all the unknown parameters
# in the first MCMC then fix and sample the other parameters in the second MCMC
# Take dict pertubations and dict chain for reuse
function threading(
model_start::BiophysicalModel,
sampler::Tuple{Sampler, Sampler},
meas::Array{Float64,2},
protocol::Protocol,
noise_model::Noisemodel,
)
datasize = size(meas)
pertubations = draw_samples(sampler[1], noise_model, "dict")
(measurements, estimates, chains, est, est_std) = pre_allocate(
model_start, sampler, datasize
)
print("MCMC sampling...")
@showprogress Threads.@threads for iv in 1:(datasize[2]::Int)
# for voxels in the same thread, use the allocated space repeatedly
td = Threads.threadid()
measurements[td] .= meas[:, iv]
# ignore voxels when normalized signals containing NaN or values larger than 1
sum(measurements[td]) == NaN && continue
maximum(measurements[td]) > 1 && continue
# if want to use the same starting point for all voxels, add these two steps
update!(estimates[td], model_start, sampler[1].params)
update!(estimates[td], sampler[1].paralinks)
mcmc!(chains[td], estimates[td], measurements[td], protocol, sampler[1], pertubations)
mcmc!(chains[td], estimates[td], measurements[td], protocol, sampler[2], pertubations)
for (ip, para) in enumerate(sampler[1].params)
est[ip][iv] = mean(
chains[td][para][(sampler[1].burnin+1):(sampler[1].thinning):(sampler[1].nsamples)]
)
est_std[ip][iv] = std(
chains[td][para][(sampler[1].burnin+1):(sampler[1].thinning):(sampler[1].nsamples)]
)
end
end
return est, est_std
end
"""
pre_allocate(
model::BiophysicalModel, sampler::Sampler, datasize::Tuple{Int64,Int64}
)
pre_allocate(
model::BiophysicalModel, sampler::Tuple{Sampler,Sampler}, datasize::Tuple{Int64,Int64}
)
Allocating spaces for caching computing results based on `model`, `sampler` and `datasize`.
`datasize` is the size of data (Nmeas, Nvoxels)
"""
function pre_allocate(
model::BiophysicalModel, sampler::Sampler, datasize::Tuple{Int64,Int64}
)
# temporal vectors to cache data in each mcmc; repeatedly used by threads
measurements = [Vector{Float64}(undef, datasize[1]) for td in 1:Threads.nthreads()]
estimates = [deepcopy(model) for td in 1:Threads.nthreads()]
# chain space for each thread
chains = [create_chain(sampler, "vec") for td in 1:Threads.nthreads()]
# arrays hosting mean and std of samples
est = []
for i in eachindex(sampler.params)
np = rand(sampler.proposal[i])
if np isa Vector
push!(est, fill(fill(NaN, length(np)), datasize[2]))
else
push!(est, [NaN for _ in 1:datasize[2]])
end
end
est_std = deepcopy(est)
return measurements, estimates, chains, est, est_std
end
function pre_allocate(
model::BiophysicalModel, sampler::Tuple{Sampler,Sampler}, datasize::Tuple{Int64,Int64}
)
# temporal vectors to cache data in each mcmc; repeatedly used by threads
measurements = [Vector{Float64}(undef, datasize[1]) for td in 1:Threads.nthreads()]
estimates = [deepcopy(model) for td in 1:Threads.nthreads()]
# chain space for each thread
chains = [create_chain(sampler[1], "dict") for td in 1:Threads.nthreads()]
# arrays hosting mean and std of samples
est = []
for i in eachindex(sampler[1].params)
np = rand(sampler[1].proposal[i])
if np isa Vector
push!(est, fill(fill(NaN, length(np)), datasize[2]))
else
push!(est, [NaN for _ in 1:datasize[2]])
end
end
est_std = deepcopy(est)
return measurements, estimates, chains, est, est_std
end
"""
create_chain(sampler, container)
create undefied container ("vec" or "dict") for saving mcmc chain
"""
function create_chain(sampler::Sampler, container::String)
example = rand.(sampler.proposal)
if container == "vec"
# vec to store chains
chain = []
for i in eachindex(example)
if example[i] isa Vector
push!(chain, vec(similar(example[i], typeof(example[i]), sampler.nsamples)))
else
push!(chain, Vector{Float64}(undef, sampler.nsamples))
end
end
# add space for sigma,logp and move for dignostics
push!(chain, Vector{Float64}(undef, sampler.nsamples))
push!(chain, Vector{Float64}(undef, sampler.nsamples))
push!(chain, Vector{Int64}(undef, sampler.nsamples))
elseif container == "dict"
# dict to store chains
chain = Dict()
for i in eachindex(example)
if example[i] isa Vector
push!(
chain,
sampler.params[i] =>
vec(similar(example[i], typeof(example[i]), sampler.nsamples)),
)
else
push!(chain, sampler.params[i] => Vector{Float64}(undef, sampler.nsamples))
end
end
# add sigma,logp and move for dignostics
push!(chain, "sigma" => Vector{Float64}(undef, sampler.nsamples))
push!(chain, "logp" => Vector{Float64}(undef, sampler.nsamples))
push!(chain, "move" => Vector{Float64}(undef, sampler.nsamples))
else
error("Use vec or dict")
end
return chain
end
"""
empty some parameters in the chain while keeping keys
"""
function empty_chain!(chain::Dict{String,Vector{Any}}, keys::Tuple{Vararg{String}})
for key in keys
empty!(chain[key])
end
empty!(chain["sigma"])
empty!(chain["logp"])
empty!(chain["move"])
return nothing
end
"""
create empty chain
"""
function empty_chain(sampler::Sampler)
# dict to store chains
chain = Dict(para => [] for para in sampler.params)
# add sigma,logp and move for dignostics
push!(chain, "sigma" => [])
push!(chain, "logp" => [])
push!(chain, "move" => [])
return chain
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 2903 | # Constants used in modelling
#
# SI units are used in computations but we need to pay attention to some conventions between text files and computation
# Units used: s (second), m (meter), T (tesla), s/m^2, m^2/s, T/m
#
# In text files, e.g. bval, techo, tdelta and tsmalldel, units are s/mm^2 for b-values and ms for times.
# Protocols reading from text files will automatically convert units based on the convention.
#
# In ploting or visualize microstructure parameters, ms (t2),um (size),and um^2/ms (diffusivity) are used.
#
# b-values: 1 ms/um^2 = 10^3 s/mm^2 = 10^9 s/m^2
# G: 1000 mT/m = 1 T/m
# diffusivity: 1 um^2/ms = 10^-9 m^2/s
using StaticArrays
"""
gyromagnetic ratio
"""
const gmr = 2.67 * 1e8 #rad/s/T
# Up to 10th order
const BesselJ_RootsCylinder = @SVector [
1.84118378134066
5.33144277352503
8.53631636634629
11.7060049025921
14.8635886339090
18.0155278626818
21.1643698591888
24.3113268572108
27.4570505710592
30.6019229726691
]
# Calculated from camino function BesselJ_RootsSphere
# Up to 31st
const BesselJ_RootsSphere = @SVector [
2.0815759778181
5.94036999057271
9.20584014293667
12.404445021902
15.5792364103872
18.7426455847748
21.8996964794928
25.052825280993
28.2033610039524
31.3520917265645
34.499514921367
37.6459603230864
40.7916552312719
43.9367614714198
47.0813974121542
50.2256516491831
53.3695918204908
56.5132704621986
59.6567290035279
62.8000005565198
65.9431119046553
69.0860849466452
72.2289377620154
75.3716854092873
78.5143405319308
81.6569138240367
84.7994143922025
87.9418500396598
91.0842274914688
94.2265525745684
97.368830362901
]
"""
scaling_factors lookup table
(parameter range, unit scaling, further scaling to similar range (<=1))
"""
const scalings_in_vivo = Dict(
"dpara" => ((0.5e-9, 3.0e-9), 1.0e9, 1.0 / 3.0),
"d0" => ((0.5e-9, 3.0e-9), 1.0e9, 1.0 / 3.0),
"diff" => ((0.5e-9, 3.0e-9), 1.0e9, 1.0 / 3.0),
"da" => ((0.1e-6, 10.0e-6), 1.0e6, 1.0 / 10.0),
"size" => ((0.1e-6, 10.0e-6), 1.0e6, 1.0 / 10.0),
"t2" => ((20.0e-3, 200.0e-3), 1.0e3, 1.0 / 200.0),
"dperp_frac" => ((0.0, 1.0), 1.0, 1.0),
"fracs" => ((0.0, 1.0), 1.0, 1.0),
"S0norm" => ((1.0, 5.0), 1.0, 1.0 / 5.0),
)
const scalings_ex_vivo = Dict(
"dpara" => ((0.1e-9, 1.2e-9), 1.0e9, 1.0 / 1.2),
"d0" => ((0.1e-9, 1.2e-9), 1.0e9, 1.0 / 1.2),
"diff" => ((0.1e-9, 2.0e-9), 1.0e9, 1.0 / 2.0),
"da" => ((0.1e-6, 10.0e-6), 1.0e6, 1.0 / 5.0),
"size" => ((0.1e-6, 10.0e-6), 1.0e6, 1.0 / 10.0),
"t2" => ((10.0e-3, 150.0e-3), 1.0e3, 1.0 / 150.0),
"dperp_frac" => ((0.0, 1.0), 1.0, 1.0),
"fracs" => ((0.0, 1.0), 1.0, 1.0),
"S0norm" => ((1.0, 5.0), 1.0, 1.0 / 5.0),
)
const scalings = Dict("in_vivo" => scalings_in_vivo, "ex_vivo" => scalings_ex_vivo)
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 115 | using Microstructure
using Test
@testset "Microstructure.jl" begin
include("test_compartment.jl")
###
end
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | code | 1686 | using Microstructure
using Test
axon = Cylinder(; da=2.0e-6)
extra = Zeppelin()
iso = Iso()
sphere = Sphere()
bval = [1000, 2500, 5000, 7500, 11100, 18100, 25000, 43000] .* 1.0e6
techo = 40.0 .* ones(8) .* 1e-3
tdelta = 15.129 .* ones(8) .* 1e-3
tsmalldel = 11.0 .* ones(8) .* 1e-3
prot = Protocol(bval, techo, tdelta, tsmalldel)
digits = 6
@test round.(compartment_signals(axon, prot), digits=digits) ==
round.(
[
0.830306256448048,
0.660977107327415,
0.500413251789382,
0.411543391237258,
0.336884386133270,
0.260507095967021,
0.218862593318336,
0.161439844983240,
],
digits=digits,
)
@test round.(compartment_signals(extra, prot), digits=digits) ==
round.(
[
0.672953994843349,
0.376716014811867,
0.148013602779966,
0.060161061844622,
0.017211501723351,
0.001665325091163,
1.789612484149176e-04,
6.163836418812522e-07,
],
digits=digits,
)
@test round.(compartment_signals(iso, prot), digits=digits) ==
round.(
[
0.135335283236613,
0.006737946999085,
4.539992976248477e-05,
3.059023205018258e-07,
2.283823312361578e-10,
1.899064673586898e-16,
1.928749847963932e-22,
4.473779306181057e-38,
],
digits=digits,
)
@test round.(compartment_signals(sphere, prot), digits=digits) ==
round.(
[
0.926383765355293,
0.825994848716073,
0.682267490105489,
0.563549432273578,
0.427936553427585,
0.250562419120995,
0.147833680281184,
0.0373258948718356,
],
digits=digits,
)
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 2396 | <img src="docs/src/assets/logo_main.png#gh-light-mode-only" width=400>
<img src="docs/src/assets/logo-dark.png#gh-dark-mode-only" width=400>
[](https://github.com/Tinggong/Microstructure.jl/actions/workflows/CI.yml?query=branch%3Amain)
Microstructure.jl is a Julia package for fast and probabilistic microstructure imaging. It features flexible and extendable compartment modeling with diffusion MRI and combined diffusion-relaxometry MRI and provides generic estimators including Markov Chain Monte Carlo (MCMC) sampling methods and Monte Carlo dropout with neural networks.
Microstructure.jl is under active development, testing and optimization and updates will be shared throughout this process. You are welcome to try it out and provide feedback on any issues encountered. Microstructure.jl has a developing [documentation website](https://tinggong.github.io/Microstructure.jl/dev/) introducing functional API and features of the package. More tutorials and recommendations will be coming soon.
**Updates!** We have a [preprint](https://arxiv.org/abs/2407.06379) if you are interested in knowing more:
Gong, T., & Yendiki, A. (2024). Microstructure. jl: a Julia Package for Probabilistic Microstructure Model Fitting with Diffusion MRI. arXiv preprint arXiv:2407.06379.
### Installation
To install Microstructure.jl, open Julia and enter the package mode by typing `]`, then add the package, which will install the latest released version:
```julia
julia> ]
(@v1.10) pkg> add Microstructure
```
If you want to keep up to date with the developing version I am working on, remove the current installation and add the repository directly:
```julia
(@v1.10) pkg> rm Microstructure
(@v1.10) pkg> add https://github.com/Tinggong/Microstructure.jl.git
```
### Relationship to Other Packages
Microstructure.jl focuses on tissue microstructure estimation. If you are also interested in fiber orientation and tractography, please check out [Fibers.jl](https://github.com/lincbrain/Fibers.jl). Additional, Microstructure.jl uses I/O functions from Fibers.jl for reading and writing NIfTI image files.
### Acknowledgements
Development of this package is supported by the NIH National Institute of Neurologic Disorders and Stroke (grants UM1-NS132358, R01-NS119911, R01-NS127353).
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 1926 | # Minimal steps
Here includes the minimal steps for you to get started with your MRI dataset. Visit tutorial and manual pages for more feature demonstrations.
### Start julia in terminal with multi-threads
```terminal
~ % julia --threads auto
```
You can also set enviornment variable by adding `export JULIA_NUM_THREADS=auto` in your bash profile, which will use multi-threads automatically when you start julia.
### Load the package in Julia
In your julia script or REPL:
```julia
julia> using Microstructure
```
### Read dMRI data and perform spherical mean
Provide full path to the DWI file and acquisition files with following extensions: dwiname.bvals, dwiname.bvecs, dwiname.techo, dwiname.tdelta and dwiname.tsmalldel. Provide all or a subset of the acquisition files depending on the data and model you use.
```julia
julia> (dMRI, protocol) = spherical_mean(
datadir * "/dwiname.nii.gz",
save=true,
datadir * "dwiname.bvals",
datadir * "dwiname.bvecs",
datadir * "dwiname.techo",
datadir * "dwiname.tdelta",
datadir * "dwiname.tsmalldel")
```
You might also need to read a tissue mask to define the region you want to process:
```julia
julia> using Fibers
julia> mask = mri_read(datadir * "/mask.nii.gz")
```
### Specify the model we want to use and get a MCMC sampler for it
Here, we use a multi-echo spherical mean model which is curently under testing as an example:
```julia
julia> model_start = MTE_SMT(axon = Stick(dpara = 1.7e-9, t2 = 90e-3), extra = Zeppelin(dpara = 1.7e-9, t2 = 60e-3))
julia> sampler_smt = Sampler(model_start)
```
### MCMC Estimation
```julia
julia> savename = datadir * "/mte_smt."
julia> threading(model_start, sampler_smt, dMRI, mask, protocol, Noisemodel(), savename)
``` | Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 3170 | # What is Microstructure.jl for?
Microstructure.jl is a Julia toolbox aiming at fast and probabilistic microstructure imaging with diffusion and combined diffusion-relaxometry MRI. Microstructure imaging enables the estimation of biologically meaningful cellular parameters from MRI data. This is achieved by simplifying the tissue within a voxel into multiple compartments representing different cellular structures, e.g. axons and cell bodies etc. Each tissue compartment has unique features that affect the MR signals under a measurement protocol, thus allowing their estimation through solving an inverse problem.
Since MRI measurements are typically noisy and exhibit varying sensitivities to tissue features, point estimation methods, which provide a single estimate of each tissue parameter, are often insufficient for understanding the meaningfulness of the estimated tissue parameters. To address this issue, many previous studies have investigated more extensive methods such as Markov Chain Monte Carlo (MCMC) sampling, to sample the posterior distributions of tissue parameters and thereby obtain the probability of the estimates. However, such methods have seen limited applications in neuroimaging studies due to the significantly longer computation time required for analyzing whole-brain datasets.
Microstructure.jl aims to reduce the computation time required for probabilistic microstructure imaging by leveraging Julia's high performance design. It does not directly address limitations in microstructure modelling itself but aims to serve as a flexible tool to better investigate modelling assumptions and model performance. General recommendations for model fitting will be shared after testing and optimization.
If you are interested, please try it out! The getting started page includes the minimal steps for beginning with your MRI dataset. Visit manual and upcoming tutorials for more feature demonstrations, recommendations and references!
### Feature Summary
- Combined diffusion-relaxometry compartment modelling
- Flexible in creating models and adjusting assumptions
- Generic MCMC and neural network estimators
- Faster MCMC with Parallel computing
- Compatible with the probabilistic programming language [Turing.jl](https://turinglang.org/dev/)
### Installation
To install Microstructure.jl, type ] in Julia to enter package mode and add the package:
```julia
julia> ]
(@v1.10) pkg> add Microstructure
```
Microstructure.jl is under active development and is frequently updated. To ensure you have the latest version, use the following command in the package mode:
```julia
(@v1.10) pkg> up Microstructure
```
### Relationship to Other Packages
Microstructure.jl focuses on tissue microstructure estimation. If you are also interested in fiber orientation and tractography, please check out [Fibers.jl](https://github.com/lincbrain/Fibers.jl). Microstructure.jl also uses I/O functions from Fibers.jl for reading and writing mri image files.
### Acknowledgements
Development of this package is supported by the NIH National Institute of Neurologic Disorders and Stroke (grants UM1-NS132358, R01-NS119911, R01-NS127353).
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 727 | # Tissue Compartments
This page introduces Compartment types with fields of relevant tissue parameters and forward functions inferencing signals from the compartment model and imaging protocol. Featuring spherical mean based models with compartmental relaxation-weighting.
## Overview
```@docs
Compartment
```
### Axonal and dendritic compartments
```@docs
Cylinder
```
```@docs
Stick
```
### Extra-cellular compartment
```@docs
Zeppelin
```
### Cell body compartment
```@docs
Microstructure.Sphere
```
### CSF and dot compartment
```@docs
Iso
```
## Compartment signals
This function implements different methods for different compartment Types to generate compartment signals.
```@docs
compartment_signals
```
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 343 | # I/O functions
This page introduces functions for reading dMRI data and protocols for microstructure imaging.
### Read from DWI data and get spherical mean signals & imaging protocols
```@docs
spherical_mean
```
### The dMRI and Protocol type
```@docs
dMRI
```
```@docs
Protocol
```
Write image and save protocol
```@docs
dmri_write
```
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 1785 | # Estimators
This page introduces two types of estimators in Microstructure.jl for estimating parameters and quantifying uncertainties: the Markov Chain Monte Carlo (MCMC) sampling method and Monte Carlo dropout using neural networks. These two types of estimators are flexibly parametrized, allowing you to specify sampling options for MCMC and training options for neural networks.
## MCMC
MCMC methods aim to generate independent samples from the posterior distributions of tissue parameters given certain MRI measurements. You will need to tune the sampler parameters for a specific biophysical model.
### Define a sampler for your model
```@docs
Sampler
```
### Define a noise model
```@docs
Noisemodel
```
### Run MCMC on your model and data
```@docs
mcmc!
```
Function mcmc! runs on single thread and suitable for testing sampler parameters and inspecting chains for small dataset. After optimizing sampler parameters, if you are processing datasets with many voxels, use the threading function for multi-threads processing. Refer to multi-threads page for more details.
## Neural Networks
This module currently includes simple multi-layer perceptrons and training data generation function, which allows supervised training of the MLPs on synthesised data with given training parameter distributions.
### Specify a network model for your task
```@docs
NetworkArg
```
### Specify training parameters
```@docs
TrainingArg
```
### Prepare network and data for training
```@docs
prepare_training
```
"prepare_training" calls two functions to generate task specific MLP and training samples:
```@docs
create_mlp
```
```@docs
generate_samples
```
### Training on generated training samples
```@docs
train_loop!
```
### Test on you data
```@docs
test
```
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 567 | # Microstructure Models
This page introduces several biophysical models. A biophysical model includes several tissue compartments and other parameters including compartment fractions and signals.
```@docs
BiophysicalModel
```
## dMRI models
### WM models
```@docs
ExCaliber
```
### GM models
```@docs
SANDI
```
```@docs
SANDIdot
```
## Combined diffusion-relaxometry models
```@docs
MTE_SMT
```
```@docs
MTE_SANDI
```
## Prediction of MRI signals
This function implements different methods for different BiophysicalModel types.
```@docs
model_signals
```
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 707 | # Multi threads
Multi-threads processing is recommended when using MCMC estimation. The neural network estimators are relatively fast and take only minutes training on CPU.
### Start julia in terminal with multi-threads
```terminal
~ % julia --threads auto
```
You can also set enviornment variable by adding `export JULIA_NUM_THREADS=auto` in your bash profile, which will use multi-threads automatically when you start julia.
### Multi-threads for MCMC estimation
```@docs
threading
```
Function threading calls pre_allocate and mcmc! for multi-threads processing. When provided sampler is a Tuple containing two Samplers, it uses a two-stage MCMC to get final estimates.
```@docs
pre_allocate
``` | Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 3802 | # How to build a microstructure model
This page introduces some simple steps for you to observe how tissue microstructrure parameters affect dMRI spherical mean signals using some biphysical models.
## 1. diffusion MRI model
Load the module
````julia
using Microstructure
````
Specify the acquisition parameters and make a protocol. In real case, you can read a protocol from your acquisition text files
````julia
bval = [0, 1000, 2500, 5000, 7500, 11100, 18100, 25000, 43000].*1.0e6
n = length(bval)
techo = 40.0.*ones(n,).*1e-3
tdelta = 15.192.*ones(n,).*1e-3
tsmalldel = 11.0.*ones(n,).*1e-3
prot = Protocol(bval,techo,tdelta,tsmalldel)
````
Specify a model containing all the tissue parameters. Here, the example ExCaliber is a model for estimating axon diameter in ex vivo tissue using the spherical mean technique
````julia
estimates = ExCaliber()
````
You can check how the tissue is modelled by printing the model. It will give you all the tissue compartments
````julia
print_model(estimates)
````
You can check the values in the tissue model by using @show macro.
This will show the default values if you didn't specify parameters when declare a model
````julia
@show estimates
````
You can specify tissue parameters when declearing a model; fields/subfiedls that are not specified will take the default values
````julia
estimates = ExCaliber( axon = Cylinder(da = 4.0e-6, dpara = 0.7e-9))
````
You can change the fields/subfields of a decleared model struct by using update! funciton.
a. update a field/subfields
````julia
undate!(estimates, "axon.da" => 5.0e-6)
````
It's common that we need to link certain tissue parameters in some models as they may not be distinguishable under the experimental condition.
b. update a field/subfield using parameter links.
````julia
update!(estimates,"axon.d0" => "axon.dpara")
````
c. update multiple parameters
````julia
update!(estimates,("axon.da" => 5.0e-6, "axon.dpara" => 0.5e-9, "axon.d0" => "axon.dpara", "extra.dpara" => "axon.dpara"))
````
Now we can use the model and protocol to generate some mri signals
````julia
signals = model_signals(estimates,prot)
````
We can add some noise to the signals to make them look like real measurements
````julia
using Random, Distributions
sigma = 0.01 # SNR=100 at S(b=0,t=TEmin) (b=0 of minimal TE)
noise = Normal(0,sigma)
````
Add some Gaussian noise
````julia
meas = signals .+ rand(noise,size(signals))
````
or Rician noise
````julia
meas_rician = sqrt.((signals .+ rand(noise,size(signals))).^2.0 .+ rand(noise,size(signals)).^2.0)
````
You can check the predict signals and simulated measurements by ploting them
````julia
using Plots
plot(prot.bval, signals, label="predicted signals", lc=:black, lw=2)
scatter!(prot.bval, meas, label="noisy measurements", mc=:red, ms=2, ma=0.5)
xlabel!("b-values [s/m^2]")
````
## 2. Combined Diffusion-relaxometry model
Now let's look at a diffusion-relaxometry model MTE-SANDI. Similarly, declear a model object and check the values
````julia
model = MTE_SANDI()
print_model(model)
@show model
````
MTE_SANDI requires data acquired at multiple echo times to solve the inverse problem and we will define a different protocol for it.
Make a multi-TE protocol
````julia
nTE = 4
nb = 9
bval = repeat([0, 1000, 2500, 5000, 7500, 11100, 18100, 25000, 43000].*1.0e6, outer=nTE)
techo = repeat([32, 45, 60, 78].*1e-3, inner=9)
tdelta = 15.192.*ones(nTE*nb,).*1e-3
tsmalldel = 11.0.*ones(nTE*nb,).*1e-3
prot = Protocol(bval,techo,tdelta,tsmalldel)
````
Let's see how multi-TE signals look like
````julia
signals = model_signals(model, prot)
meas = signals .+ rand(noise,size(signals))
plot(signals, label="predicted signals", lc=:black, lw=2)
scatter!(meas, label="noisy measurements", mc=:red, ms=2, ma=0.5)
````
| Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 67 | # How to check quality of fitting and mcmc samples
Constructing... | Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 88 | # How to generate training datasets
Constructing...
Also checkout Manual - Estimators | Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 57 | # How to evaluate accuracy and precision
Constructing... | Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.6 | a7c86ae9e497817fe18b7580eaceb1c7d3304b92 | docs | 37 | # Which model to use
Constructing... | Microstructure | https://github.com/Tinggong/Microstructure.jl.git |
|
[
"MIT"
] | 0.1.13 | 4b15e702e8b0385a4696f520250030529eb29269 | code | 8766 | __precompile__(true)
module PandasLite
using PyCall
using Compat
using TableTraits
using Dates
export values, np, pd
export @pytype, @pyasvec
include("index.jl")
const np = PyNULL()
const pd = PyNULL()
function __init__()
copy!(np, pyimport_conda("numpy", "numpy"))
copy!(pd, pyimport_conda("pandas", "pandas"))
empty!(type_map) # for behaving nicely in system image
for (pandas_expr, julia_type) in pre_type_map
type_map[pandas_expr()] = julia_type
end
for (pytype, jltype) in type_map
PyCall.pytype_mapping(pytype, jltype)
end
PyCall.pytype_mapping(np.float32, Float32)
PyCall.pytype_mapping(np.float64, Float64)
PyCall.pytype_mapping(np.int32, Int32)
PyCall.pytype_mapping(np.int64, Int64)
if get(ENV, "PD_NO_CONSOLID", "0") == "1"
noconsolidation()
end
end
version() = VersionNumber(pd.__version__)
const pre_type_map = []
# Maps a python object corresponding to a PandasLite class to a Julia type which
# wraps that class.
const type_map = Dict{PyObject, Type}()
abstract type PandasWrapped end
PyCall.PyObject(x::PandasWrapped) = x.pyo
macro pytype(name, class)
quote
mutable struct $(name) <: PandasWrapped
pyo::PyObject
$(esc(name))(pyo::PyObject) = new(pyo)
$(esc(name))(args...; kwargs...) = ($class)()(args...; kwargs...)
end
# This won't work until PyCall is updated to support
# the Julia 1.0 iteration protocol.
function Base.iterate(x::$name, state...)
res = Base.iterate(x.pyo, state...)
if res === nothing
return nothing
else
value, state = res
return value, state
end
end
Base.convert(::Type{$name}, o::PyObject) = $name(o)
push!(pre_type_map, ($class, $name))
end
end
function Base.Array(x::PyObject)
if hasproperty(x, :dtype)
x_kind = x.dtype.kind
if x_kind == "M"
return map(z -> unix2datetime(z / 1e9), x.view("int64"))
elseif x_kind == "m"
return map(z -> Millisecond(z / 1e6), x.view("int64"))
elseif x_kind == "O" && get(x, 0) isa String
return convert(Array{String}, x)
elseif x_kind == "O"
return map(z -> convert(PyAny, z), convert(PyAny, x))
end
end
convert(PyAny, x)
end
Base.Array(x::PandasWrapped) = Array(x."values")
function Base.values(x::PandasWrapped)
# Zero-copy conversion to a Julia native type is possible
if hasproperty(x.pyo, :dtype)
x_kind = x.dtype.kind
if x_kind in ["i", "u", "f", "b"]
pyarray = convert(PyArray, x."values")
if pyarray.f_contig
dims, T, ptr = size(pyarray), eltype(pyarray), pyarray.data
if Int(ptr) % Base.datatype_alignment(T) == 0
return unsafe_wrap(Array, ptr, dims)
else
Aflat = unsafe_wrap(Array, Ptr{UInt8}(ptr), prod(dims) * sizeof(T))
return reshape(reinterpret(T, Aflat), dims)
end
end
end
end
Array(x)
end
struct StringRange{T <: AbstractString}
start::T
stop::T
end
(::Colon)(start::T, stop::T) where T <: AbstractString = StringRange{T}(start, stop)
Base.show(io::IO, r::StringRange) =
print(io, '"', r.start, '"', ':', '"', r.stop, '"')
PyCall.PyObject(x::Colon) = pybuiltin("slice")(nothing, nothing, nothing)
PyCall.PyObject(x::StringRange) = pybuiltin("slice")(x.start, x.stop)
fix_arg(x) = x
fix_arg(x::StepRange) = pybuiltin("slice")(x.start, x.start + length(x) * x.step, x.step)
fix_arg(x::UnitRange) = fix_arg(StepRange(x.start, 1, x.stop))
fix_arg(x, offset) = fix_arg(x)
fix_arg(x::Union{Integer, AbstractArray{<:Integer}}, offset) = offset ? fix_arg(x .- 1) : fix_arg(x)
macro pyasvec(class)
index_expr = quote
function Base.getindex(pyt::$class, args...)
offset = should_offset(pyt, args...)
new_args = tuple([fix_arg(arg, offset) for arg in args]...)
new_args = (length(new_args) == 1 ? new_args[1] : new_args)
pyt.__getitem__(new_args)
end
Base.view(pyt::$class, is...) = Base.getindex(x, is...)
function Base.setindex!(pyt::$class, value, idxs...)
offset = should_offset(pyt, idxs...)
new_idx = [fix_arg(idx, offset) for idx in idxs]
if length(new_idx) > 1
pyt.__setitem__(tuple(new_idx...), value)
else
pyt.__setitem__(new_idx[1], value)
end
end
end
length_expr = if class in [:Iloc, :Loc]
:(Base.length(x::$class) = x.obj.__len__())
else
:(Base.length(x::$class) = x.__len__())
end
quote
$index_expr
$length_expr
Base.lastindex(x::$class) = length(x)
Base.lastindex(x::$class, i) = size(x, i)
end
end
@pytype DataFrame () -> pd.core.frame."DataFrame"
@pytype Series () -> pd.core.series."Series"
@pytype Iloc () -> pd.core.indexing."_iLocIndexer"
@pytype Loc () -> pd.core.indexing."_LocIndexer"
@pytype Index () -> version() < VersionNumber(1) ? pd.core.index."Index" : pd.core.indexes.multi."Index"
@pytype MultiIndex () -> version() < VersionNumber(1) ? pd.core.index."MultiIndex" : pd.core.indexes.multi."MultiIndex"
@pytype GroupBy () -> pd.core.groupby."DataFrameGroupBy"
@pytype SeriesGroupBy () -> pd.core.groupby."SeriesGroupBy"
@pytype Rolling () -> pd.core.window."Rolling"
export DataFrame, Series, Iloc, Index, MultiIndex, GroupBy, SeriesGroupBy, Rolling
Base.size(x::Union{Loc, Iloc}) = x.obj.shape
Base.size(df::PandasWrapped, i::Integer) = size(df)[i]
Base.size(df::PandasWrapped) = df.shape
Base.ndims(df::PandasWrapped) = length(size(df))
Base.isempty(df::PandasWrapped) = df.empty
Base.empty!(df::PandasWrapped) = df.drop(df.index, inplace = true)
should_offset(::Any, args...) = false
should_offset(::Union{Iloc, Index, MultiIndex}, args...) = true
@pyasvec Series
@pyasvec Loc
@pyasvec Iloc
@pyasvec DataFrame
@pyasvec Index
@pyasvec MultiIndex
@pyasvec GroupBy
@pyasvec SeriesGroupBy
@pyasvec Rolling
Base.show(io::IO, df::PandasWrapped) = println(io, df.__str__())
for (jl_op, py_op, py_opᵒ) in [(:+, :__add__, :__add__), (:*, :__mul__, :__mul__),
(:/, :__truediv__, :__rtruediv__), (:-, :__sub__, :__rsub__),
(:(==), :__eq__, :__eq__), (:!=, :__ne__, :__ne__),
(:>, :__gt__, :__lt__), (:<, :__lt__, :__gt__),
(:>=, :__ge__, :__le__), (:<=, :__le__, :__ge__),
(:&, :__and__, :__and__), (:|, :__or__, :__or__)]
@eval begin
Base.$jl_op(x::PandasWrapped, y) = x.$py_op(y)
Base.$jl_op(y, x::PandasWrapped) = x.$py_opᵒ(y)
Base.$jl_op(x::PandasWrapped, y::PandasWrapped) = invoke($jl_op, Tuple{PandasWrapped, Any}, x, y)
end
end
for (jl_op, py_op) in [(:-, :__neg__), (:!, :__neg__)]
@eval Base.$jl_op(x::PandasWrapped) = x.$py_op()
end
include("operators_v6.jl")
DataFrame(pairs::Pair...) = DataFrame(Dict(pairs...))
function Base.eltype(s::Series)
dtype_map = Dict(
np.dtype("int8") => Int8,
np.dtype("uint8") => UInt8,
np.dtype("int16") => Int16,
np.dtype("uint16") => UInt16,
np.dtype("int32") => Int32,
np.dtype("uint32") => UInt32,
np.dtype("int64") => Int64,
np.dtype("uint64") => UInt64,
np.dtype("float16") => Float16,
np.dtype("float32") => Float32,
np.dtype("float64") => Float64,
np.dtype("object") => String,
)
get(dtype_map, s.dtype, Any)
end
Base.eltype(df::DataFrame) = Tuple{[eltype(df[c]) for c in df.columns]...}
function Base.map(f::Function, s::Series)
if eltype(s) <: Real
Series([f(_) for _ in values(s)])
else
Series([f(_) for _ in s])
end
end
Base.get(df::PandasWrapped, key, default) = df.get(key, default)
Base.getindex(s::Series, c::CartesianIndex{1}) = s[c[1]]
Base.copy(df::PandasWrapped) = df.copy()
include("tabletraits.jl")
function DataFrame(obj)
y = _construct_pandas_from_iterabletable(obj)
if y === nothing
return invoke(DataFrame, Tuple{Vararg{Any}}, obj)
else
return y
end
end
Base.getproperty(x::PandasWrapped, s::Symbol) = s == :pyo ? getfield(x, s) : getproperty(x.pyo, s)
Base.getproperty(x::PandasWrapped, s::String) = getproperty(x.pyo, s)
function Base.setproperty!(x::PandasWrapped, s::Symbol, v)
if s == :pyo
return setfield!(x, s, v)
else
setproperty!(x.pyo, s, v)
end
end
include("miscellaneous.jl")
end
| PandasLite | https://github.com/AStupidBear/PandasLite.jl.git |
|
[
"MIT"
] | 0.1.13 | 4b15e702e8b0385a4696f520250030529eb29269 | code | 925 | Base.getindex(o::PyObject, s) = o.__getitem__(s)
Base.getindex(o::PyObject, is...) = getindex(o, is)
Base.setindex!(o::PyObject, v, s) = o.__setitem__(s, v)
Base.setindex!(o::PyObject, v, is...) = setindex!(o, v, is)
Base.getindex(o::PyObject, s::Union{Symbol, AbstractString}) = invoke(getindex, Tuple{PyObject, Any}, o, s)
Base.setindex!(o::PyObject, v, s::Union{Symbol, AbstractString}) = invoke(setindex!, Tuple{PyObject, Any, Any}, o, v, s)
Base.getindex(o::PyObject, i::Integer) = invoke(getindex, Tuple{PyObject, Any}, o, i)
Base.getindex(o::PyObject, i1::Integer, i2::Integer) = getindex(o, (i1, i2))
Base.getindex(o::PyObject, is::Integer...) = getindex(o, is)
Base.setindex!(o::PyObject, v, i::Integer) = invoke(setindex!, Tuple{PyObject, Any, Any}, o, v, i)
Base.setindex!(o::PyObject, v, i1::Integer, i2::Integer) = setindex!(o, (i1, i2), v)
Base.setindex!(o::PyObject, v, is::Integer...) = setindex!(o, is, v)
| PandasLite | https://github.com/AStupidBear/PandasLite.jl.git |
|
[
"MIT"
] | 0.1.13 | 4b15e702e8b0385a4696f520250030529eb29269 | code | 1258 | export pdhcat, pdvcat, noconsolidation
Base.setindex!(df::DataFrame, v::AbstractArray, col::Union{Symbol, String}) = setindex!(df, v, [col])
function Base.setindex!(df::DataFrame, v::AbstractArray, cols)
if isempty(df)
df_merge = DataFrame(v, copy = false, columns = cols)
df.pyo = df_merge.pyo
elseif size(v, 1) == length(df) && !issubset(cols, df.columns)
ndims(v) == 1 && (v = reshape(v, :, 1))
df_set = DataFrame(v, copy = false, columns = cols, index = df.index)
df_merge = df.merge(df_set, left_index = true, right_index = true, copy = false)
df.pyo = df_merge.pyo
else
df[cols] = DataFrame(v)
end
return df
end
function pdhcat(dfs...)
dfs = filter(!isempty, collect(dfs))
df = dfs[1]
for dfn in dfs[2:end]
df = df.merge(dfn, left_index = true, right_index = true, copy = false)
end
return df
end
pdvcat(xs...) = pd.concat([xs...], axis = 0, ignore_index = true)
function noconsolidation()
py"""
def _consolidate_inplace(self):
pass
def _consolidate(self):
return self.blocks
from pandas.core.internals import BlockManager
BlockManager._consolidate_inplace = _consolidate_inplace
BlockManager._consolidate = _consolidate
"""
end
| PandasLite | https://github.com/AStupidBear/PandasLite.jl.git |
|
[
"MIT"
] | 0.1.13 | 4b15e702e8b0385a4696f520250030529eb29269 | code | 323 | import Base: ==, >, <, >=, <=, !=
for (op, pyop) in [(:(==), :__eq__), (:>, :__gt__), (:<, :__lt__), (:>=, :__ge__), (:<=, :__le__), (:!=, :__ne__)]
@eval function Base.broadcast(::typeof($op), s::PandasWrapped, x)
method = s.pyo.$(QuoteNode(pyop))
pandas_wrap(pycall(method, PyObject, x))
end
end
| PandasLite | https://github.com/AStupidBear/PandasLite.jl.git |
|
[
"MIT"
] | 0.1.13 | 4b15e702e8b0385a4696f520250030529eb29269 | code | 1757 | using IteratorInterfaceExtensions
using TableTraitsUtils
import DataValues
IteratorInterfaceExtensions.isiterable(x::DataFrame) = true
TableTraits.isiterabletable(x::DataFrame) = true
function TableTraits.getiterator(df::DataFrame)
col_names_raw = [c for c in df.columns]
col_names = Symbol.(col_names_raw)
column_data = [eltype(df[c]) == String ? [df[c].iloc[j] for j in 1:length(df)] : values(df[c]) for c in col_names_raw]
return create_tableiterator(column_data, col_names)
end
TableTraits.supports_get_columns_copy_using_missing(df::DataFrame) = true
function TableTraits.get_columns_copy_using_missing(df::PandasLite.DataFrame)
# return a named tuple of columns here
col_names_raw = [c for c in df.columns]
col_names = Symbol.(col_names_raw)
cols = (Array(eltype(df[c]) == String ? [df[c].iloc[j] for j in 1:length(df)] : df[c]) for c in col_names_raw)
return NamedTuple{tuple(col_names...)}(tuple(cols...))
end
function _construct_pandas_from_iterabletable(source)
y = create_columns_from_iterabletable(source, errorhandling = :returnvalue)
isnothing(y) && return nothing
columns, column_names = y[1], y[2]
cols = Dict{Symbol,Any}(i[1] => i[2] for i in zip(column_names, columns))
for (k,v) in pairs(cols)
if eltype(v) <: DataValues.DataValue
T = eltype(eltype(v))
if T <: AbstractFloat
cols[k] = T[get(i, NaN) for i in v]
elseif T <: Integer
cols[k] = Float64[DataValues.isna(i) ? NaN : Float64(get(i)) for i in v]
else
throw(ArgumentError("Can't create a PandasLite.DataFrame from a source that has missing data."))
end
end
end
return DataFrame(cols)
end
| PandasLite | https://github.com/AStupidBear/PandasLite.jl.git |
|
[
"MIT"
] | 0.1.13 | 4b15e702e8b0385a4696f520250030529eb29269 | code | 1390 | using PandasLite
using Dates
using Test
df = pd.DataFrame(Dict(:name => ["a", "b"], :age => [27, 30]))
age = values(df.age)
age[2] = 31
@test df.loc[1, "age"] == 31
df = pd.read_csv(joinpath(dirname(@__FILE__), "test.csv"))
@test isa(df, PandasLite.DataFrame)
include("test_tabletraits.jl")
@test !isempty(df)
empty!(df)
@test isempty(df)
x = pd.Series([3, 5], index = [:a, :b])
@test x.a == 3
@test x["a"] == 3
@test x.loc["a"] == 3
@test x.b == 5
@test x.iloc[1] == 3
@test x.iloc[2] == 5
@test x.iloc[end] == 5
@test length(x) == 2
@test values(x + 1) == [4, 6]
@test x.sum() == 8
@test eltype(x) == Int
@test all(x.iloc[1:2] == x)
# rolling
roll = pd.Series([1,2,3,4,5]).rolling(3)
@test isequal(values(roll.mean()), [NaN, NaN, 2.0, 3.0, 4.0])
# groupy
group = pd.DataFrame(Dict("group" => ["a", "b", "a"], "value" => [1, 2, 3])).groupby("group")[["value"]]
@test isequal(values(group.sum()), [4; 2;;])
df = pd.DataFrame()
df["a"] = [1]
df["b"] = pd.to_datetime("2015-01-01")
df["c"] = pd.to_timedelta("0.5 hour")
df["d"] = "abcde"
@test Array(df["a"]) == values(df["a"]) == [1]
@test Array(df["b"]) == values(df["b"]) == [DateTime(2015, 1, 1)]
@test Array(df["c"]) == values(df["c"]) == [Millisecond(1800000)]
@test Array(df["d"]) == values(df["d"]) == ["abcde"]
@test Array(df["a"] / 2) == values(df["a"] / 2) == [0.5]
@test Array(2 / df["a"]) == values(2 / df["a"]) == [2]
| PandasLite | https://github.com/AStupidBear/PandasLite.jl.git |
|
[
"MIT"
] | 0.1.13 | 4b15e702e8b0385a4696f520250030529eb29269 | code | 1702 | using PandasLite
using IteratorInterfaceExtensions
using TableTraits
using DataValues
using Test
@testset "TableTraits" begin
table_array = [(a=1, b="John", c=3.2), (a=2, b="Sally", c=5.8)]
df = DataFrame(table_array)
@test collect(df.columns) == ["a", "b", "c"]
@test values(df[:a]) == [1,2]
@test values(df[:c]) == [3.2, 5.8]
@test [df[:b].iloc[i] for i in 1:2] == ["John", "Sally"]
@test TableTraits.isiterabletable(df) == true
it = IteratorInterfaceExtensions.getiterator(df)
@test eltype(it) == NamedTuple{(:a,:b,:c),Tuple{Int,String,Float64}}
it_collected = collect(it)
@test eltype(it_collected) == NamedTuple{(:a,:b,:c),Tuple{Int,String,Float64}}
@test length(it_collected) == 2
@test it_collected[1] == (a=1, b="John", c=3.2)
@test it_collected[2] == (a=2, b="Sally", c=5.8)
@test TableTraits.supports_get_columns_copy_using_missing(df) == true
cols = TableTraits.get_columns_copy_using_missing(df)
@test cols == (a=[1,2], b=["John", "Sally"], c=[3.2, 5.8])
table_array2 = [(a=1, b=DataValue("John"), c=3.2), (a=2, b=DataValue("Sally"), c=5.8)]
@test_throws ArgumentError DataFrame(table_array2)
table_array3 = [(a=DataValue{Int}(), b="John", c=DataValue(3.2)), (a=DataValue(2), b="Sally", c=DataValue{Float64}())]
df3 = DataFrame(table_array3)
it3_collected = collect(IteratorInterfaceExtensions.getiterator(df3))
@test length(it3_collected) == 2
@test isnan(it3_collected[1].a)
@test it3_collected[1].b == "John"
@test it3_collected[1].c == 3.2
@test it3_collected[2].a == 2
@test it3_collected[2].b == "Sally"
@test isnan(it3_collected[2].c)
cols3 = TableTraits.get_columns_copy_using_missing(df3)
@test isequal(cols3, (a=[NaN,2.], b=["John", "Sally"], c=[3.2, NaN]))
end
| PandasLite | https://github.com/AStupidBear/PandasLite.jl.git |
|
[
"MIT"
] | 0.1.13 | 4b15e702e8b0385a4696f520250030529eb29269 | docs | 3611 | PandasLite.jl
=============
[](https://github.com/AStupidBear/PandasLite.jl/actions)
[](https://codecov.io/gh/AStupidBear/PandasLite.jl)
A fork of Pandas.jl whose syntax is closer to native pandas.
This package provides a Julia interface to the excellent [pandas](http://pandas.pydata.org/pandas-docs/stable/) package. It sticks closely to the pandas API. One exception is that integer-based indexing is automatically converted from Python's 0-based indexing to Julia's 1-based indexing.
Installation
--------------
You must have pandas installed. Usually you can do that on the command line by typing
```
pip install pandas
```
It also comes with the Anaconda and Enthought Python distributions.
Then in Julia, type
```julia
Pkg.add("PandasLite")
using PandasLite
```
Usage
---------
```julia
>> using PandasLite
>> df = DataFrame(Dict(:age=>[27, 29, 27], :name=>["James", "Jill", "Jake"]))
age name
0 27 James
1 29 Jill
2 27 Jake
[3 rows x 2 columns]
>> df.describe()
age
count 3.000000
mean 27.666667
std 1.154701
min 27.000000
25% 27.000000
50% 27.000000
75% 28.000000
max 29.000000
[8 rows x 1 columns]
df[:age]
0 27
1 29
2 27
Name: age, dtype: int64
>> df2 = DataFrame(Dict(:income=>[45, 101, 87]), index=["Jake", "James", "Jill"])
>> df3 = df.merge(df2, left_on="name", right_index=true)
age name income
0 27 James 101
1 29 Jill 87
2 27 Jake 45
[3 rows x 3 columns]
>> df3.iloc[1:2, 2:3]
name income
0 James 101
1 Jill 87
[2 rows x 2 columns]
>> df3.groupby("age").mean()
income
age
27 73
29 87
[2 rows x 1 columns]
>> df3.query("income>85")
age name income
0 27 James 101
1 29 Jill 87
[2 rows x 3 columns]
>> Array(df3)
3x3 Array{Any,2}:
27 "James" 101
29 "Jill" 87
27 "Jake" 45
>> df3.plot()
```
Input/Output
-------------
Example:
```julia
df = pd.read_csv("my_csv_file.csv") # Read in a CSV file as a dataframe
df.to_json("my_json_file.json") # Save a dataframe to disk in JSON format
```
Performance
------------
Most PandasLite operations on medium to large dataframes are very fast, since the overhead of calling into the Python API is small compared to the time spent inside PandasLite' highly efficient C implementation.
Setting and getting individual elements of a dataframe or series is slow however, since it requires a round-trip of communication with Python for each operation. Instead, use the ``values`` method to get a version of a series or homogeneous dataframe that requires no copying and is as fast to access and write to as a Julia native array. Example:
```julia
>> x_series = Series(randn(10000))
>> @time x[1]
elapsed time: 0.000121945 seconds (2644 bytes allocated)
>> x_values = values(x_series)
>> @time x_values[1]
elapsed time: 2.041e-6 seconds (64 bytes allocated)
>> x_native = randn(10000)
>> @time x[1]
elapsed time: 2.689e-6 seconds (64 bytes allocated)
```
Changes to the values(...) array propogate back to the underlying series/dataframe:
```julia
>> x_series.iloc[1]
-0.38390854447454037
>> x_values[1] = 10
>> x_series.iloc[1]
10
```
Caveats
----------
Panels-related functions are still unwrapped, as well as a few other obscure functions. Note that even if a function is not wrapped explicitly, it can still be called using various methods from [PyCall](https://github.com/stevengj/PyCall.jl).
| PandasLite | https://github.com/AStupidBear/PandasLite.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 2152 | module RenderJay
const SMALL_NUM = 0.000001
const GREAT_NUM = 100000.0
const p = 1.0/(2.0 * pi)
const INV_PI = 1.0/pi
using CSV, LightXML, DataFrames, DelimitedFiles, LinearAlgebra, ProgressMeter, SharedArrays, ImageMagick, Images
include("structs.jl")
export normalize
export Asset
export Bvh
export Camera
export Coord
export Geometry
export Cylinder
export Cone
export Mesh
export Point
export Ray
export Hook
include("transform.jl")
export translate_ray
export transform_tzy
export carthesian2spherical
export spherical2carthesian
export relazi
export get_extremes
export transform
export transform_forward
export transform_inverse
export rotate_forward
export rotate_inverse
export weibull
include("create.jl")
export create_ray
export create_coords
include("bvh.jl")
export make_boxes
export produce_bvh_data
export median_cut
export build_containing_box
export produce_bounding_boxes
export make_bvh
include("light.jl")
export make_sky
export background_radiance
export sample_skymap
include("render.jl")
export trace_back
export render_pixel
export render_image
include("brdf.jl")
export cross_scalars
export normalize_scalars
export project2normal
export sample_f
export propagate
export compute_propagation_of_reflectance
export compute_propagation_of_transmittance
export distr
export geom
export fresnel
export cooktorrance
export compute_half_vector
export ct_sampler
export pure_reflection
export rpv
include("intersect.jl")
export hit_box
export intersect_bvh
export intersect
export intersect_scene
include("shader.jl")
export lambertian_shader
export bilambertian_shader
export pure_reflection_shader
export rpv_shader
export lambertian_path_shader
export bilambertian_path_shader
export rpv_path_shader
export pure_reflection_path_shader
export lightsource_path_shader
include("io.jl")
export read_shaders
export read_items
export read_items_no_load_bvh
export read_items_load_bvh
export read_camera
export read_skymap
export read_scene
export read_cylinder_data
export read_cylinder
export read_cone_data
export read_cone
export read_mesh_data
export read_mesh
export write_bvh
export read_bvh
end # module
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 5978 | function cross_scalars(ax::T, ay::T, az::T, bx::T, by::T, bz::T) where {T<:AbstractFloat}
cx = ay*bz-az*by
cy = az*bx-ax*bz
cz = ax*by-ay*bx
return cx, cy, cz
end
function normalize_scalars(x::T, y::T, z::T) where {T<:AbstractFloat}
l = sqrt(x*x + y*y + z*z)
x = x / l
y = y / l
z = z / l
return x, y, z
end
function project2normal(fx::T, fy::T, fz::T, nx::T, ny::T, nz::T) where {T<:AbstractFloat}
ax::T = 0.0034
ay::T = 0.0071
az::T = 1.0000
bx, by, bz = cross_scalars(ax, ay, az, nx, ny, nz)
cx, cy, cz = normalize_scalars(bx, by, bz)
dx, dy, dz = cross_scalars(cx, cy, cz, nx, ny, nz)
ex, ey, ez = normalize_scalars(dx, dy, dz)
gx, gy, gz = normalize_scalars(fx, fy, fz)
hx = gx * ex + gy * cx + gz * nx
hy = gx * ey + gy * cy + gz * ny
hz = gx * ez + gy * cz + gz * nz
return hx, hy, hz
end
function sample_f()
x1 = rand()
x2 = rand()
phi = x1*2.0*pi
theta = acos(x2)
return theta, phi
end
function propagate(Ix::T, Iy::T, Iz::T, dx::T, dy::T, dz::T) where {T<:AbstractFloat}
x = Ix + dx * SMALL_NUM
y = Iy + dy * SMALL_NUM
z = Iz + dz * SMALL_NUM
ray = Ray(x, y, z, dx, dy, dz)
return ray
end
function compute_propagation_of_reflectance(Ix::T, Iy::T, Iz::T, nx::T, ny::T, nz::T) where {T<:AbstractFloat}
t, p = sample_f()
fx, fy, fz = spherical2carthesian(t, p)
dx, dy, dz = project2normal(fx, fy, fz, nx, ny, nz)
x = Ix + dx * SMALL_NUM
y = Iy + dy * SMALL_NUM
z = Iz + dz * SMALL_NUM
ray = Ray(x, y, z, dx, dy, dz)
return ray
end
function compute_propagation_of_transmittance(Ix::T, Iy::T, Iz::T, nx::T, ny::T, nz::T) where {T<:AbstractFloat}
t, p = sample_f()
fx, fy, fz = spherical2carthesian(t, p)
dx, dy, dz = project2normal(fx, fy, fz, -nx, -ny, -nz)
x = Ix + dx * SMALL_NUM
y = Iy + dy * SMALL_NUM
z = Iz + dz * SMALL_NUM
ray = Ray(x, y, z, dx, dy, dz)
return ray
end
function distr(nx::T, ny::T, nz::T, hx::T, hy::T, hz::T, alpha::T) where {T<:AbstractFloat}
alpha2 = alpha^2
NoH = nx*hx+ny*hy+nz*hz
NoH2 = NoH*NoH
den = NoH2 * alpha2 + (1 - NoH2)
chi = NoH > 0 ? 1 : 0
return (chi * alpha2) / (np.pi * den * den)
end
function geom(vx::T, vy::T, vz::T, nx::T, ny::T, nz::T, hx::T, hy::T, hz::T, alpha::T) where {T<:AbstractFloat}
VoH = vx*hx + vy*hy + vz*hz
VoN = vx*nx + vy*ny + vz*nz
m = VoH/VoN
chi = m > 0 ? 1 : 0
VoH2 = VoH * VoH
tan2 = (1 - VoH2) / VoH2
return (chi*2) / (1 + sqrt(1 + alpha * alpha * tan2))
end
function fresnel(vx::T, vy::T, vz::T, hx::T, hy::T, hz::T, eta::T, k::T) where {T<:AbstractFloat}
VoH = vx*hx + vy*hy + vz*hz
k2 = k^2
num = (eta-1)^2 + 4*eta*(1-VoH)^5 + k2
den = (eta+1)^2 + k^2
return num/den
end
function cooktorrance(vx::T, vy::T, vz::T, nx::T, ny::T, nz::T, sx::T, sy::T, sz::T, alpha::T, eta::T, k::T) where {T<:AbstractFloat}
h = compute_half_vector(vx, vy, vz, sx, sy, sz)
F = fresnel(vx, vh, vz, hx, hy, hz, eta, k)
G = geom(vx, vy, vz, nx, ny, nz, hx, hy, hz, alpha) * geom(sx, sy, sz, nx, ny, nz, hx, hy, hz, alpha)
D = distr(nx, ny, nz, hx, hy, hz, alpha)
cosT = sx*nx + sy*ny + sz*nz
sinT = sqrt(1-cosT*cosT)
nom = F*G*D*sinT
NoV = nx*vx + ny*vy + nz*vz
HoN = nx*hx + ny*hy + nz*hz
den = 4*NoV*HoN+0.05
fs = nom/den
return fs
end
function compute_half_vector(vx::T, vy::T, vz::T, sx::T, sy::T, sz::T) where {T<:AbstractFloat}
hx, hy, hz = normalize_scalars(vx+sx, vy+sy, vz+sz)
return hx, hy, hz
end
function ct_sampler(alpa::T) where {T<:AbstractFloat}
jota1, jota2 = rand(2)
num = alpha * sqrt(jota1)
den = sqrt(1-jota1)
theta = atan(num/den)
phi = jota2*2.0*pi
return theta, phi
end
function pure_reflection(vx::T, vy::T, vz::T, nx::T, ny::T, nz::T) where {T<:AbstractFloat}
NoV = nx*vx + ny*vy + nz*vz
rx = 2.0 * NoV * nx - vx
ry = 2.0 * NoV * ny - vy
rz = 2.0 * NoV * nz - vz
return rx, ry, rz
end
function rpv(theta_zero::T, theta::T, phi::T, rho_zero::T, rho_c::T, captheta::T, k::T) where {T<:AbstractFloat}
cos_theta = cos(theta)
cos_theta_zero = cos(theta_zero)
cos_phi = cos(phi)
tan_theta_zero = tan(theta_zero)
tan_theta = tan(theta)
cosg = cos_theta*cos_theta_zero + sin(theta)*sin(theta_zero)*cos_phi
captheta_square = captheta^2
G = ((tan_theta_zero^2 + tan_theta^2) - (2*tan_theta_zero*tan_theta*cos_phi))^0.5
M = (cos_theta_zero^(k-1) * cos_theta^(k-1)) / (cos_theta_zero+cos_theta)^(k-1)
FHG = (1-captheta_square) / (1+2*captheta*cosg+captheta_square)^1.5
H = 1+(1-rho_c)/(1+G)
rho_sfc = rho_zero * M * FHG * H
return rho_sfc
end
function rpv(theta_zero::T, theta::T, phi::T, rho_zero::Array{T}, rho_c::Array{T}, captheta::Array{T}, k::Array{T}) where {T<:AbstractFloat}
cos_theta = cos(theta)
cos_theta_zero = cos(theta_zero)
cos_phi = cos(phi)
tan_theta_zero = tan(theta_zero)
tan_theta = tan(theta)
cosg = cos_theta*cos_theta_zero + sin(theta)*sin(theta_zero)*cos_phi
G = ((tan_theta_zero^2 + tan_theta^2) - (2*tan_theta_zero*tan_theta*cos_phi))^0.5
n = size(k,1)
rho_sfc = Array{T}(undef, n)
for i=1:n
captheta_square = captheta[i]^2
M = (cos_theta_zero^(k[i]-1) * cos_theta^(k[i]-1)) / (cos_theta_zero+cos_theta)^(k[i]-1)
FHG = (1 - captheta_square) / (1 + 2 * captheta[i] * cosg + captheta_square)^1.5
H = 1 + (1 - rho_c[i]) / (1 + G)
rho_sfc[i] = rho_zero[i] * M * FHG * H
end
return rho_sfc
end
function rpv(vx::T, vy::T, vz::T, nx::T, ny::T, nz::T, sx::T, sy::T, sz::T, rho_zero::T, rho_c::T, captheta::T, k::T) where {T<:AbstractFloat}
phi = relazi(vn, vy, vz, nx, ny, nz, sx, sy, sz)
theta = acos(vx*nx + vy*ny + vz*nz)
theta_zero = acos(sx*nx + sy*ny + sz*nz)
rho_sfc = RPV(theta_zero, theta, phi, rho_zero, rho_c, captheta, k)
return rho_sfc
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 9164 |
function make_boxes(box::Vector{T}, n::S, scale_factor::T) where {T<:AbstractFloat, S<:Integer}
# Generates data for testing bvh, returns a set of n boxes inside box
minx, miny, minz, maxx, maxy, maxz = box
dx::T = abs(maxx - minx) * (1.0 - scale_factor)
dy::T = abs(maxy - miny) * (1.0 - scale_factor)
dz::T = abs(maxz - minz) * (1.0 - scale_factor)
sx::T = abs(maxx - minx) * scale_factor
sy::T = abs(maxy - miny) * scale_factor
sz::T = abs(maxz - minz) * scale_factor
newBoxes::Array{T,2} = zeros(6, n)
for i=1:n
a = rand() * dx + minx
b = rand() * dy + miny
c = rand() * dz + minz
newBoxes[:,i] = [a, b, c, a+sx, b+sy, c+sz]
end
return newBoxes
end
function produce_bvh_data(bounding_boxes::Array{T,2}) where T<:AbstractFloat
# BVH with one leaf per end node
n::Int = size(bounding_boxes, 2)
m::Int = 2*n-1
outerbox::Vector{T} = build_containing_box(bounding_boxes)
bvh_boxes::Array{T,2} = zeros(6, m)
bvh_boxes[:,1] = outerbox
bb2bvh::Array{Int,1} = ones(n) # bounding boxes pointing to their node in the bvh
bvh2bb::Array{Int,1} = zeros(m)
bb_idx::Array{Int,1} = collect(1:n)
left_child::Array{Int} = ones(m)
right_child::Array{Int} = ones(m)
writeCursor::Int = 1
#axis::Char = 'x'
cutDirection::Array{Char} = ['x' for i::Int = 1:m]
@showprogress for readCursor::Int = 1:m # sequence through the BVH nodes top-down and slice, if multiple leaves are left within
#if readCursor % 1000 === 0
# println(readCursor, " / ", m)
#end
subset_idx = bb_idx[bb2bvh .== readCursor]
if size(subset_idx, 1) == 0
continue
end
if size(subset_idx, 1) == 1
bvh2bb[readCursor] = subset_idx[1]
end
if size(subset_idx, 1) > 1
axis = cutDirection[readCursor]
idxs_left, idxs_right, axis = median_cut(bounding_boxes[:,subset_idx]; axis=axis)
idxs_left, idxs_right = subset_idx[idxs_left], subset_idx[idxs_right]
writeCursor += 1
bvh_boxes[:,writeCursor] = build_containing_box(bounding_boxes[:,idxs_left])
bb2bvh[idxs_left] .= writeCursor
left_child[readCursor] = writeCursor
cutDirection[writeCursor] = axis
writeCursor += 1
bvh_boxes[:,writeCursor] = build_containing_box(bounding_boxes[:,idxs_right])
bb2bvh[idxs_right] .= writeCursor
right_child[readCursor] = writeCursor
cutDirection[writeCursor] = axis
end
end
# 1D arrays seem to be faster than a 2D array, even if column-major...
minx::Array{T,1} = bvh_boxes[1,:]
miny::Array{T,1} = bvh_boxes[2,:]
minz::Array{T,1} = bvh_boxes[3,:]
maxx::Array{T,1} = bvh_boxes[4,:]
maxy::Array{T,1} = bvh_boxes[5,:]
maxz::Array{T,1} = bvh_boxes[6,:]
return minx, miny, minz, maxx, maxy, maxz, bvh2bb, left_child, right_child, bb2bvh
end
function median_cut(bounding_boxes::Array{T,2}; axis::Char=x) where {T<:AbstractFloat}
n::Int = size(bounding_boxes,2)
a::Vector{T} = zeros(n)
if axis == 'x'
for i::Int = 1:n
a[i] = bounding_boxes[1,i]
end
s = sortperm(a)
m = floor(Int, size(a,1) / 2)
idx_left = s[1:m]
idx_right = s[m+1:end]
axis = 'y'
elseif axis == 'y'
for i::Int = 1:n
a[i] = bounding_boxes[2,i]
end
s = sortperm(a)
m = floor(Int, size(a,1) / 2)
idx_left = s[1:m]
idx_right = s[m+1:end]
axis = 'z'
elseif axis == 'z'
for i::Int = 1:n
a[i] = bounding_boxes[3,i]
end
s = sortperm(a)
m = floor(Int, size(a,1) / 2)
idx_left = s[1:m]
idx_right = s[m+1:end]
axis = 'x'
end
return idx_left, idx_right, axis
end
function build_containing_box(boxes::Array{T,2}) where {T<:AbstractFloat}
minx::T = Inf
miny::T = Inf
minz::T = Inf
maxx::T = -1.0*Inf
maxy::T = -1.0*Inf
maxz::T = -1.0*Inf
n::Int = size(boxes,2)
for i::Int = 1:n
if boxes[1,i] < minx # minPoint.x
minx = boxes[1,i]
end
if boxes[4,i] > maxx # maxPoint.x
maxx = boxes[4,i]
end
if boxes[2,i] < miny # minPoint.y
miny = boxes[2,i]
end
if boxes[5,i] > maxy # maxPoint.y
maxy = boxes[5,i]
end
if boxes[3,i] < minz # minPoint.z
minz = boxes[3,i]
end
if boxes[6,i] > maxz # maxPoint.z
maxz = boxes[6,i]
end
end
box::Vector{T} = [minx, miny, minz, maxx, maxy, maxz]
return box
end
function produce_bounding_boxes(mesh::Mesh)
n = size(mesh.v1x, 1)
boxes::Array{Float32, 2} = zeros(6, n)
for i=1:n
minx = min(mesh.v1x[i], mesh.v2x[i], mesh.v3x[i])
miny = min(mesh.v1y[i], mesh.v2y[i], mesh.v3y[i])
minz = min(mesh.v1z[i], mesh.v2z[i], mesh.v3z[i])
maxx = max(mesh.v1x[i], mesh.v2x[i], mesh.v3x[i])
maxy = max(mesh.v1y[i], mesh.v2y[i], mesh.v3y[i])
maxz = max(mesh.v1z[i], mesh.v2z[i], mesh.v3z[i])
boxes[:,i] = [minx, miny, minz, maxx, maxy, maxz]
end
return boxes
end
function produce_bounding_boxes(cylinder::Cylinder)
n = size(cylinder.m1x, 1)
boxes::Array{Float32, 2} = zeros(6, n)
for i=1:n
minx = min(cylinder.m1x[i], cylinder.m2x[i])
miny = min(cylinder.m1y[i], cylinder.m2y[i])
minz = min(cylinder.m1z[i], cylinder.m2z[i])
maxx = max(cylinder.m1x[i], cylinder.m2x[i])
maxy = max(cylinder.m1y[i], cylinder.m2y[i])
maxz = max(cylinder.m1z[i], cylinder.m2z[i])
r = cylinder.radius[i]
boxes[:,i] = [minx-r, miny-r, minz-r, maxx+r, maxy+r, maxz+r]
end
return boxes
end
function produce_bounding_boxes(cone::Cone)
n = size(cone.m1x, 1)
boxes::Array{Float32, 2} = zeros(6, n)
for i=1:n
minx = min(cone.m1x[i] - cone.radius_base[i], cone.v2x[i] - cone.radius_tip[i])
miny = min(cone.m1y[i] - cone.radius_base[i], cone.v2y[i] - cone.radius_tip[i])
minz = min(cone.m1z[i] - cone.radius_base[i], cone.v2z[i] - cone.radius_tip[i])
maxx = max(cone.m1x[i] + cone.radius_base[i], cone.v2x[i] + cone.radius_tip[i])
maxy = max(cone.m1y[i] + cone.radius_base[i], cone.v2y[i] + cone.radius_tip[i])
maxz = max(cone.m1z[i] + cone.radius_base[i], cone.v2z[i] + cone.radius_tip[i])
boxes[:,i] = [minx, miny, minz, maxx, maxy, maxz]
end
return boxes
end
function make_bvh(bb::AbstractArray{T}) where {T<:AbstractFloat}
# create bvh from bounding boxes (6xN array)
minx, miny, minz, maxx, maxy, maxz, bvh2bb, left_child, right_child, bb2bvh = produce_bvh_data(bb)
bvh = Bvh(minx, miny, minz, maxx, maxy, maxz, bvh2bb, left_child, right_child)
return bvh
end
function make_bvh(geometry::Geometry{T,S,A,E}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray, E<:AbstractArray}
# use this function only for meshes; scenes are handled below...
boxes = produce_bounding_boxes(geometry)
minx, miny, minz, maxx, maxy, maxz, bvh2bb, left_child, right_child, bb2bvh = produce_bvh_data(boxes)
bvh = Bvh(minx, miny, minz, maxx, maxy, maxz, bvh2bb, left_child, right_child)
return bvh
end
function make_bvh(assets::Array{Asset{Float64, Int64},1}, mesh_bvhs::Array{Bvh{Float64, Int64, Array{Float64,1}, Array{Int64,1}},1})
n = size(assets, 1)
boxes::Array{Float64, 2} = zeros(6, n)
for i=1:n
p = assets[i].oidx
xoff = assets[i].xoff
yoff = assets[i].yoff
zoff = assets[i].zoff
beta = assets[i].beta
gamma = assets[i].gamma
xmin = mesh_bvhs[p].xmin[1]
ymin = mesh_bvhs[p].ymin[1]
zmin = mesh_bvhs[p].zmin[1]
xmax = mesh_bvhs[p].xmax[1]
ymax = mesh_bvhs[p].ymax[1]
zmax = mesh_bvhs[p].zmax[1]
x1, y1, z1 = transform(xmin, ymin, zmin, xoff, yoff, zoff, beta, gamma)
x2, y2, z2 = transform(xmin, ymin, zmax, xoff, yoff, zoff, beta, gamma)
x3, y3, z3 = transform(xmin, ymax, zmin, xoff, yoff, zoff, beta, gamma)
x4, y4, z4 = transform(xmin, ymax, zmax, xoff, yoff, zoff, beta, gamma)
x5, y5, z5 = transform(xmax, ymin, zmin, xoff, yoff, zoff, beta, gamma)
x6, y6, z6 = transform(xmax, ymin, zmax, xoff, yoff, zoff, beta, gamma)
x7, y7, z7 = transform(xmax, ymax, zmin, xoff, yoff, zoff, beta, gamma)
x8, y8, z8 = transform(xmax, ymax, zmax, xoff, yoff, zoff, beta, gamma)
txmin = min(x1, x2, x3, x4, x5, x6, x7, x8)
tymin = min(y1, y2, y3, y4, y5, y6, y7, y8)
tzmin = min(z1, z2, z3, z4, z5, z6, z7, z8)
txmax = max(x1, x2, x3, x4, x5, x6, x7, x8)
tymax = max(y1, y2, y3, y4, y5, y6, y7, y8)
tzmax = max(z1, z2, z3, z4, z5, z6, z7, z8)
boxes[:,i] = [txmin, tymin, tzmin, txmax, tymax, tzmax]
end
minx, miny, minz, maxx, maxy, maxz, bvh2bb, left_child, right_child, bb2bvh = produce_bvh_data(boxes)
scene_bvh::Bvh{Float64, Int64, Array{Float64,1}, Array{Int64,1}} = Bvh(minx, miny, minz, maxx, maxy, maxz, bvh2bb, left_child, right_child)
return scene_bvh
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 684 | function create_ray(x1::T, y1::T, z1::T, x2::T, y2::T, z2::T) where {T<:AbstractFloat}
dx = x2 - x1
dy = y2 - y1
dz = z2 - z1
l = sqrt((dx^dx) + (dy*dy) + (dz*dz))
dx = dx / l
dy = dy / l
dz = dz / l
ray = Ray(x1, y1, z1, dx, dy, dz)
return ray
end
function create_coords(camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}}
# construct an array of coordinate, just for the shape...
coords = Array{Coord{S}}(undef, camera.xResolution, camera.yResolution)
for x::S=1:camera.xResolution
for y::S=1:camera.yResolution
coords[x,y] = Coord(x, y)
end
end
return coords
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 9376 | function hit_box(minx::T, miny::T, minz::T, maxx::T, maxy::T, maxz::T, ray::Ray{T}) where {T<:AbstractFloat}
minx2v1 = minx - ray.x
maxx2v1 = maxx - ray.x
miny2v1 = miny - ray.y
maxy2v1 = maxy - ray.y
minz2v1 = minz - ray.z
maxz2v1 = maxz - ray.z
tmin = minx2v1 / ray.dx
tmax = maxx2v1 / ray.dx
if tmin > tmax
tmin, tmax = tmax, tmin
end
tymin = miny2v1 / ray.dy
tymax = maxy2v1 / ray.dy
if tymin > tymax
tymin, tymax = tymax, tymin
end
if (tmin > tymax) || (tymin > tmax)
return false
end
if tymin > tmin
tmin = tymin
end
if tymax < tmax
tmax = tymax
end
tzmin = minz2v1 / ray.dz
tzmax = maxz2v1 / ray.dz
if tzmin > tzmax
tzmin, tzmax = tzmax, tzmin
end
if (tmin > tzmax) || (tzmin > tmax)
return false
end
return true
end
function intersect_bvh(bvh::Bvh{T,S,A,E}, ray::Ray{T}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
#NOTE:these two vector take about a third of the time of this function and furthermore the pushes take a long time too...
# the hit_box line takes surprisingly little, with only 586/4505
q::Vector = [1]
leaf_idxs::Vector{S} = []
while size(q, 1) > 0
i = pop!(q)
minx, miny, minz, maxx, maxy, maxz = bvh.xmin[i], bvh.ymin[i], bvh.zmin[i], bvh.xmax[i], bvh.ymax[i], bvh.zmax[i]
if hit_box(minx, miny, minz, maxx, maxy, maxz, ray)::Bool
if bvh.left_child[i] > 1 && bvh.right_child[i] > 1
q = push!(q, bvh.left_child[i], bvh.right_child[i])
end
if bvh.bvh2bb[i] > 0
leaf_idxs = push!(leaf_idxs, bvh.bvh2bb[i])
end
end
end
return leaf_idxs
end
function intersect(cone::Cone{T,S,A,E}, i::S, ray::Ray) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray, E<:AbstractArray}
# intersect ray with cone/cylinder...
xoff = cone.m1x[i]
yoff = cone.m1y[i]
zoff = cone.m1z[i]
beta = cone.beta[i]
gamma = cone.gamma[i]
tray = transform_tzy(ray, -xoff, -yoff, -zoff, -beta, -gamma)
a::Float64 = tray.dx^2 + tray.dy^2 - tray.dz^2 * cone.aa[i]
b::Float64 = 2 * tray.x * tray.dx + 2 * tray.y * tray.dy - 2 * cone.r1a[i] * tray.dz - 2 * tray.z * ray.dz * cone.aa[i]
c::Float64 = tray.x^2 + tray.y^2 - cone.r1sq[i] - 2 * cone.r1a[i] * tray.z - cone.aa[i] * tray.z^2
d::Float64 = b^2 - (4*a*c)
t1::Float64 = Inf
t2::Float64 = Inf
t::Float64 = Inf
if d > 0
t1 = (-1.0*b - sqrt(d))/(2*a)
t2 = (-1.0*b + sqrt(d))/(2*a)
end
# choose the smallest, non-negative solution for t
if t1 <= 0
if t2 > 0
t = t2
end
else
if t2 <= 0
t = t1
elseif t1 < t2
t = t1
else
t = t2
end
end
# t1 and t2 can both be negative, hence t can be negative!
hit::Bool = false
tI = Point{T}(tray.x + tray.dx * t, tray.y + tray.dy * t, tray.z + tray.dz * t)
if (t > 0) && (tI.z > 0.0) && (tI.z < cone.length[i])
hit = true
end
I = Point{T}(ray.x + ray.dx * t, ray.y + ray.dy * t, ray.z + ray.dz * t)
xx::Float64 = tI.x^2
yy::Float64 = tI.y^2
rcirc::Float64 = sqrt(xx + yy)
nx::Float64, ny::Float64, nz::Float64 = normalize(tI.x, tI.y, cone.a[i] * -1.0 * rcirc)
nx, ny, nz = transform(nx, ny, nz, xoff, yoff, zoff, beta, gamma)
normal::Point = Point{T}(nx, ny, nz)
return hit, I, normal, t
end
function intersect(cylinder::Cylinder{T,S,A,E}, i::S, ray::Ray) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray, E<:AbstractArray}
# intersect ray with cylinder...
xoff = cylinder.m1x[i]
yoff = cylinder.m1y[i]
zoff = cylinder.m1z[i]
beta = cylinder.beta[i]
gamma = cylinder.gamma[i]
tray = transform_tzy(ray, -xoff, -yoff, -zoff, -beta, -gamma)
a::Float64 = tray.dx^2 + tray.dy^2
b::Float64 = 2 * tray.x * tray.dx + 2 * tray.y * tray.dy
c::Float64 = tray.x^2 + tray.y^2 - cylinder.rsq[i]
d::Float64 = b^2 - (4*a*c)
t1::Float64 = Inf
t2::Float64 = Inf
t::Float64 = Inf
if d > 0
t1 = (-1.0*b - sqrt(d))/(2*a)
t2 = (-1.0*b + sqrt(d))/(2*a)
end
# choose the smallest, non-negative solution for t
if t1 <= 0
if t2 > 0
t = t2
end
else
if t2 <= 0
t = t1
elseif t1 < t2
t = t1
else
t = t2
end
end
# t1 and t2 can both be negative, hence t can be negative!
hit::Bool = false
tI = Point{T}(tray.x + tray.dx * t, tray.y + tray.dy * t, tray.z + tray.dz * t)
if (t > 0) && (tI.z > 0.0) && (tI.z < cylinder.length[i])
hit = true
end
I = Point{T}(ray.x + ray.dx * t, ray.y + ray.dy * t, ray.z + ray.dz * t)
nx::Float64, ny::Float64, nz::Float64 = normalize(tI.x, tI.y, 0.0)
nx, ny, nz = transform(nx, ny, nz, xoff, yoff, zoff, beta, gamma)
normal::Point = Point{T}(nx, ny, nz)
return hit, I, normal, t
end
function intersect(mesh::Mesh{T,S,A,E}, i::S, ray::Ray{T}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
w0x = ray.x - mesh.v1x[i]
w0y = ray.y - mesh.v1y[i]
w0z = ray.z - mesh.v1z[i]
a = -((mesh.nx[i] * w0x) + (mesh.ny[i] * w0y) + (mesh.nz[i] * w0z))
b = (ray.dx * mesh.nx[i]) + (ray.dy * mesh.ny[i]) + (ray.dz * mesh.nz[i])
if abs(b) < SMALL_NUM
nullPoint = Point{T}(Inf, Inf, Inf)
return false, nullPoint, nullPoint, Inf # parallel
end
r = a / b
if r < 0.0
nullPoint = Point{T}(Inf, Inf, Inf)
return false, nullPoint, nullPoint, r # away
end
# point of plane intersection
x = ray.x + r * ray.dx
y = ray.y + r * ray.dy
z = ray.z + r * ray.dz
I = Point{T}(x, y, z)
N = Point{T}(mesh.nx[i], mesh.ny[i], mesh.nz[i])
mx = x - mesh.v1x[i]
my = y - mesh.v1y[i]
mz = z - mesh.v1z[i]
mu = (mx * mesh.ux[i]) + (my * mesh.uy[i]) + (mz * mesh.uz[i])
mw = (mx * mesh.wx[i]) + (my * mesh.wy[i]) + (mz * mesh.wz[i])
s = ((mesh.uw[i] * mw) - (mesh.ww[i] * mu)) / mesh.D[i]
if (s < 0.0) | (s > 1.0)
return false, I, N, r # outside
end
t = ((mesh.uw[i] * mu) - (mesh.uu[i] * mw)) / mesh.D[i]
if (t < 0.0) | ((s + t) > 1.0)
return false, I, N, r # outside
end
return true, I, N, r # ray intersects triangle
end
function intersect(geometry::Geometry{T,S,A,E}, ray::Ray{T}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
hit::Bool = false
In::Point{T} = Point{T}(Inf, Inf, Inf)
eidx::S = 0
normal::Point{T} = Point{T}(Inf, Inf, Inf)
rmin::T = Inf
# intersect mesh facets
eidxs::Array{S,1} = collect(1:size(geometry.mtl, 1))
for i::S in eidxs
hit_, Ix_, Iy_, Iz_, r_ = intersect(geometry, i, ray)
if (hit_ === true) && (r_ < rmin)
eidx = i
rmin = r_
In = Point{T}(Ix_, Iy_, Iz_)
normal = Point{T}(nx, ny, nz)
hit = true
end
end
return hit, In, eidx, normal, rmin
end
function intersect(geometry::Geometry{T,S,A,E}, bvh::Bvh{T,S,A,E}, ray::Ray{T}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
hit::Bool = false
In::Point{T} = Point{T}(Inf, Inf, Inf)
eidx::S = 0
normal::Point{T} = Point{T}(Inf, Inf, Inf)
rmin::T = Inf
# intersect mesh facets
#eidxs = collect(1:size(geometry.mtl, 1))
eidxs::Array{S,1} = intersect_bvh(bvh, ray)
for i::S in eidxs
# and see if it is nearest
hit_, I_, N_, r_ = intersect(geometry, i, ray)
if (hit_ === true) && (r_ < rmin)
eidx = i
rmin = r_
In = I_
normal = N_
hit = true
end
end
return hit, In, eidx, normal, rmin
end
function intersect_scene(assets::Array{Asset{T,S},1}, geometries::AbstractArray{Geometry{T,S,A,E},1}, geometry_bvhs::AbstractArray{Bvh{T,S,A,E},1}, scene_bvh::Bvh{T,S,A,E}, ray::Ray{T}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
hit::Bool = false
In::Point{T} = Point{T}(Inf, Inf, Inf)
nrml::Point{T} = Point{T}(Inf, Inf, Inf)
tray::Ray{T} = Ray{T}(Inf, Inf, Inf, Inf, Inf, Inf)
rmin::T = Inf
instidx::S = 0
aidx::S = 0 # asset index
oidx::S = 0 # object index / geometry index
eidx::S = 0 # element index (of the geometry indexed with oidx)
#aidxs::Array{S} = collect(1:length(assets))
aidxs::Array{S} = intersect_bvh(scene_bvh, ray)
for i::S in aidxs
oidx_ = assets[i].oidx
xoff = assets[i].xoff
yoff = assets[i].yoff
zoff = assets[i].zoff
beta = assets[i].beta
gamma = assets[i].gamma
geometry = geometries[oidx_]
geometry_bvh = geometry_bvhs[oidx_]
tray_ = transform_tzy(ray, -xoff, -yoff, -zoff, -beta, -gamma)
hit_, In_, eidx_, nrml_, rmin_ = intersect(geometry, geometry_bvh, tray_)
if (hit_ === true) && (rmin_ < rmin)
hit = true
x = ray.x + ray.dx * rmin_
y = ray.y + ray.dy * rmin_
z = ray.z + ray.dz * rmin_
In = Point{T}(x, y, z)
tray = tray_
nrml = nrml_
rmin = rmin_
aidx = i
oidx = oidx_
eidx = eidx_
end
end
return hit, In, tray, nrml, rmin, aidx, oidx, eidx
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 16555 | ##################################################################
#
# I/O functionality...
#
##################################################################
# to specify the type of the "geometries" array
allequal(x) = all(y->y==x[1],x)
function read_shaders(shaderXML::Array{XMLElement,1})
shaders = Function[]
for el in shaderXML
n = find_element(el, "function")
shaderName = content(n)
s = Symbol(shaderName)
shader = getfield(Main, s)
args = child_elements(find_element(el, "args"))
d = Dict()
for arg in args
if occursin(",", content(arg)) # array of values...
a = parse.(Float64, split(content(arg), ","))
varName = Symbol(name(arg))
push!(d, varName => a)
else # a scalar...
b = convert(Float64, content(arg))
varName = Symbol(name(arg))
push!(d, varName => b)
end
end
# assert that number of arguments equals number of specified spectral bands (i.e., for camera)...
# not sure how to implement such an assertion...
f = (Ix, Iy, Iz, vx, vy, vz, nx, ny, nz) -> shader(Ix, Iy, Iz, vx, vy, vz, nx, ny, nz; d...)
shaders = push!(shaders, f)
#ds = push!(ds, d)
end
return shaders #, ds
end
function read_items(xroot::XMLElement ; add_one=false, load_bvh=true, base_path::AbstractString="")
if load_bvh
assets, geometries, palettes, geometry_bvhs = read_items_load_bvh(xroot ; add_one=add_one, base_path=base_path)
return assets, geometries, palettes, geometry_bvhs
else
assets, geometries, palettes = read_items_no_load_bvh(xroot ; add_one=add_one, base_path=base_path)
return assets, geometries, palettes
end
end
function read_items_no_load_bvh(xroot::XMLElement ; add_one=false, base_path::AbstractString="")
oid = 0
pid = 0
assets = Asset{Float64, Int64}[]
geom_args = []
geometries = Array{Geometry{Float64, Int64, Array{Float64,1}, Array{Int64,1}},1}(undef, 0) # could implement a supertype Geometry?
palettes = Array{Vector{Function},1}(undef, 0)
@showprogress for item in xroot["item"]
# collect geometry...
geometry_type = attribute(item, "geometry")
geometry_src = attribute(item, "src")
if !isabspath(geometry_src)
geometry_src = joinpath(base_path, geometry_src)
end
geom_arg = (geometry_type, geometry_src)
# check if geometry in set; add if not...
if !(geom_arg in geom_args)
if geometry_type === "mesh"
geometry = read_mesh(geometry_src; add_one=add_one, load_bvh=false)
push!(geometries, geometry)
elseif geometry_type === "cylinder"
geometry = read_cylinder(geometry_src; add_one=add_one, load_bvh=false)
push!(geometries, geometry)
elseif geometry_type === "cone"
geometry = read_cone(geometry_src; add_one=add_one, load_bvh=false)
push!(geometries, geometry)
elseif geometry_type === "balls"
geometry = read_ball(geometry_src; add_one=add_one, load_bvh=false)
push!(geometries, geometry)
else
println( string("Cannot read << ", geometry_src, " >> of type << ", geometry_type, " >>, skipping item...") )
continue
end
push!(geom_args, geom_arg)
end
# find the index...
oid = -1
for (j, v) in enumerate(geom_args)
if geom_arg == v
oid = j
end
end
# collect shaders (notice that palettes do not have to be unique,
# unlike geometries which are bigger/consume more memory...
palette = read_shaders(item["shader"])
push!(palettes, palette)
pid += 1
# collect hooks...
hooks = item["hook"]
for hook in hooks
x = parse(Float64, content(hook["x"][1]))
y = parse(Float64, content(hook["y"][1]))
z = parse(Float64, content(hook["z"][1]))
beta = parse(Float64, content(hook["beta"][1]))
gamma = parse(Float64, content(hook["gamma"][1]))
asset = Asset(x, y, z, beta, gamma, oid, pid)
push!(assets, asset)
end
end
# conversion may or may not help you, but will first
# require new functions to be defined for render_pixel,
# specific for mesh, cylinder, ball, disk...
## convert array of type Any[] to a precise composite type, if at all possible...
#if allequal([typeof(geometries[i]) for i=1:length(geometries)])
# geometries = convert.(typeof(geometries[1]), geometries)
#end
return assets, geometries, palettes
end
function read_items_load_bvh(xroot::XMLElement ; add_one=false, base_path::AbstractString="")
oid = 0
pid = 0
assets = Asset{Float64, Int64}[]
geom_args = []
geometries = Array{Geometry{Float64, Int64, Array{Float64,1}, Array{Int64,1}},1}(undef, 0) # could implement a supertype Geometry?
geometry_bvhs = Array{Bvh{Float64, Int64, Array{Float64,1}, Array{Int64,1}},1}(undef, 0)
palettes = Array{Vector{Function},1}(undef, 0)
@showprogress for item in xroot["item"]
# collect geometry...
geometry_type = attribute(item, "geometry")
geometry_src = attribute(item, "src")
if !isabspath(geometry_src)
geometry_src = joinpath(base_path, geometry_src)
end
geom_arg = (geometry_type, geometry_src)
# check if geometry in set; add if not...
if !(geom_arg in geom_args)
if geometry_type === "mesh"
geometry, bvh = read_mesh(geometry_src; add_one=add_one, load_bvh=true)
push!(geometries, geometry)
push!(geometry_bvhs, bvh)
elseif geometry_type === "cylinder"
geometry, bvh = read_cylinder(geometry_src; add_one=add_one, load_bvh=true)
push!(geometries, geometry)
push!(geometry_bvhs, bvh)
elseif geometry_type === "cone"
geometry, bvh = read_cone(geometry_src; add_one=add_one, load_bvh=true)
push!(geometries, geometry)
push!(geometry_bvhs, bvh)
elseif geometry_type === "balls"
geometry, bvh = read_ball(geometry_src; add_one=add_one, load_bvh=true)
push!(geometries, geometry)
push!(geometry_bvhs, bvh)
else
println( string("Cannot read << ", geometry_src, " >> of type << ", geometry_type, " >>, skipping item...") )
continue
end
push!(geom_args, geom_arg)
end
# find the index...
oid = -1
for (j, v) in enumerate(geom_args)
if geom_arg == v
oid = j
end
end
# collect shaders (notice that palettes do not have to be unique,
# unlike geometries which are bigger/consume more memory...
palette = read_shaders(item["shader"])
push!(palettes, palette)
pid += 1
# collect hooks...
hooks = item["hook"]
for hook in hooks
x = parse(Float64, content(hook["x"][1]))
y = parse(Float64, content(hook["y"][1]))
z = parse(Float64, content(hook["z"][1]))
beta = parse(Float64, content(hook["beta"][1]))
gamma = parse(Float64, content(hook["gamma"][1]))
asset = Asset(x, y, z, beta, gamma, oid, pid)
push!(assets, asset)
end
end
# conversion may or may not help you, but will first
# require new functions to be defined for render_pixel,
# specific for mesh, cylinder, ball, disk...
# convert array of type Any[] to a precise composite type, if at all possible...
#if allequal([typeof(geometries[i]) for i=1:length(geometries)])
# geometries = convert.(typeof(geometries[1]), geometries)
#end
return assets, geometries, palettes, geometry_bvhs
end
function read_camera(xroot::XMLElement)
u = xroot["camera"][1]
eyeX = parse(Float64, content(find_element(u, "eyeX")))
eyeY = parse(Float64, content(find_element(u, "eyeY")))
eyeZ = parse(Float64, content(find_element(u, "eyeZ")))
lookX = parse(Float64, content(find_element(u, "lookX")))
lookY = parse(Float64, content(find_element(u, "lookY")))
lookZ = parse(Float64, content(find_element(u, "lookZ")))
eyePoint = [eyeX, eyeY, eyeZ]
lookAtPoint = [lookX, lookY, lookZ]
fov = parse(Float64, content(find_element(u, "fov")))
xRes = parse(Int, content(find_element(u, "xResolution")))
yRes = parse(Int, content(find_element(u, "yResolution")))
nBands = parse(Int, content(find_element(u, "nBands")))
rppx = parse(Int, content(find_element(u, "rppx")))
nBounces = parse(Int, content(find_element(u, "nBounces")))
camera = Camera(eyePoint, lookAtPoint, fov, xRes, yRes, nBands, rppx, nBounces)
return camera
end
function read_skymap(xroot::XMLElement ; base_path::AbstractString="")
sky_src = attribute(xroot["sky"][1], "src")
if !isabspath(sky_src)
sky_src = joinpath(base_path, sky_src)
end
skymap = readdlm(sky_src, ',', Float64)
return skymap
end
function read_scene(scenefn::AbstractString ; add_one=false)
# scenefn is the full path (and filename) of the scene (XML) file
abs_scenefn = abspath(scenefn)
base_path, _ = splitdir(abs_scenefn)
f = read(abs_scenefn, String)
xml = parse_file(abs_scenefn)
xroot = root(xml)
assets, geometries, palettes, geometry_bvhs = read_items(xroot ; add_one=add_one, load_bvh=true, base_path=base_path)
camera = read_camera(xroot)
skymap = read_skymap(xroot ; base_path=base_path)
abs_scene_bvhfn = string(abs_scenefn[1:end-3], "csv")
if !isfile(abs_scene_bvhfn)
scene_bvh = make_bvh(assets, geometry_bvhs)
write_bvh(scene_bvh, abs_scene_bvhfn)
end
scene_bvh = read_bvh(abs_scene_bvhfn)
return assets, geometries, palettes, geometry_bvhs, scene_bvh, skymap, camera
end
function read_cylinder_data(cylinder_src; add_one=false)
# loading the axes and diameters...
mfn = joinpath(cylinder_src, "m.csv")
lfn = joinpath(cylinder_src, "l.csv")
dfn = joinpath(cylinder_src, "d.csv")
mtlfn = joinpath(cylinder_src, "mtl.csv")
m::Array{Float64, 2} = readdlm(mfn, ',', Float64)
l::Array{Int, 2} = readdlm(lfn, ',', Int)
d::Array{Float64, 1} = vec(readdlm(dfn, ',', Float64))
mtl::Array{Int, 1} = vec(readdlm(mtlfn, ',', Int))
if add_one
t += 1
end
return m, l, d, mtl
end
function read_cylinder(cylinder_src::AbstractString; add_one=false, load_bvh=true)
m, l, d, mtl = read_cylinder_data(cylinder_src; add_one=add_one)
cylinder = Cylinder(m, l, d, mtl)
if load_bvh === true
bvhfn = joinpath(cylinder_src, "bvh.csv")
if !isfile(bvhfn)
bvh = make_bvh(cylinder)
write_bvh(bvh, bvhfn)
end
bvh = read_bvh(bvhfn)
return cylinder, bvh
else
return cylinder
end
end
function read_cone_data(cone_src::AbstractString; add_one=false)
# loading the axes and diameters...
mfn = joinpath(cone_src, "m.csv")
lfn = joinpath(cone_src, "l.csv")
d1fn = joinpath(cone_src, "d1.csv")
d2fn = joinpath(cone_src, "d2.csv")
mtlfn = joinpath(cone_src, "mtl.csv")
m::Array{Float64, 2} = readdlm(mfn, ',', Float64)
l::Array{Int, 2} = readdlm(lfn, ',', Int)
d1::Array{Float64, 1} = vec(readdlm(df1n, ',', Float64))
d2::Array{Float64, 1} = vec(readdlm(df2n, ',', Float64))
mtl::Array{Int, 1} = vec(readdlm(mtlfn, ',', Int))
if add_one
t += 1
end
return m, l, d1, d2, mtl
end
function read_cone(cone_src::AbstractString; add_one=false, load_bvh=true)
m, l, d, mtl = read_cone_data(cone_src; add_one=add_one)
cone = Cone(m, l, d, mtl)
if load_bvh === true
bvhfn = joinpath(cone_src, "bvh.csv")
if !isfile(bvhfn)
bvh = make_bvh(cone)
write_bvh(bvh, bvhfn)
end
bvh = read_bvh(bvhfn)
return cone, bvh
else
return cone
end
end
function read_disk_data(disk_scr::AbstractString; add_one=false)
# loading the centers, normal vectors, and diameters...
pfn = joinpath(disk_scr, "/p.csv")
nfn = joinpath(disk_scr, "/n.csv")
dfn = joinpath(disk_scr, "/d.csv")
mtlfn = joinpath(disk_scr, "/mtl.csv")
p::Array{Float64, 2} = readdlm(pfn, ',', Float64)
n::Array{Int, 2} = readdlm(nfn, ',', Int)
d::Array{Float64, 1} = vec(readdlm(dfn, ',', Float64))
mtl::Array{Int, 1} = vec(readdlm(mtlfn, ',', Int))
if add_one
t += 1
end
return p, n, d, mtl
end
function read_disk(disk_scr::AbstractString; add_one=false, load_bvh=true)
p, n, d, mtl = read_disk_data(disk_scr; add_one=add_one)
disk = Disk(p, n, d, mtl)
if load_bvh === true
bvhfn = joinpath(disk_scr, "/bvh.csv")
if !isfile(bvhfn)
bvh = make_bvh(disk)
write_bvh(bvh, bvhfn)
end
bvh = read_bvh(bvhfn)
return disk, bvh
else
return disk
end
end
function read_ball_data(ball_scr::AbstractString; add_one=false)
# loading the centers, normal vectors, and diameters...
pfn = joinpath(ball_scr, "/p.csv")
dfn = joinpath(ball_src, "/d.csv")
mtlfn = string(ball_scr, "/mtl.csv")
p::Array{Float64, 2} = readdlm(pfn, ',', Float64)
n::Array{Int, 2} = readdlm(nfn, ',', Int)
d::Array{Float64, 1} = vec(readdlm(dfn, ',', Float64))
mtl::Array{Int, 1} = vec(readdlm(mtlfn, ',', Int))
if add_one
t += 1
end
return p, d, mtl
end
function read_ball(ball_scr::AbstractString; add_one=false, load_bvh=true)
p, d, mtl = read_ball_data(ball_scr; add_one=add_one)
ball = Ball(p, d, mtl)
if load_bvh === true
bvhfn = joinpath(ball_scr, "/bvh.csv")
if !isfile(bvhfn)
bvh = make_bvh(ball)
write_bvh(bvh, bvhfn)
end
bvh = read_bvh(bvhfn)
return ball, bvh
else
return ball
end
end
function read_mesh_data(mesh_src; add_one=false)
# loading the triangles and creating the mesh...
vfn = joinpath(mesh_src, "v.csv")
tfn = joinpath(mesh_src, "t.csv")
mtlfn = joinpath(mesh_src, "mtl.csv")
v::Array{Float64, 2} = readdlm(vfn, ',', Float64)
t::Array{Int, 2} = readdlm(tfn, ',', Int)
if add_one
t += 1
end
mtl::Array{Int, 1} = vec(readdlm(mtlfn, ',', Int))
return v, t, mtl
end
function read_mesh(mesh_src::AbstractString; add_one=false, load_bvh=true)
# mesh_src is the full path of the mesh folder, where the v, t and mtl files are stored
v, t, mtl = read_mesh_data(mesh_src; add_one=add_one)
mesh = Mesh(v, t, mtl)
if load_bvh === true
bvhfn = joinpath(mesh_src, "bvh.csv")
if !isfile(bvhfn)
bvh = make_bvh(mesh)
write_bvh(bvh, bvhfn)
end
bvh = read_bvh(bvhfn)
return mesh, bvh
else
return mesh
end
end
function write_bvh(bvh::Bvh, bvhfn::AbstractString)
# bvhfn is the full path (and filename) of the BVH
df = DataFrame(xmin=bvh.xmin, ymin=bvh.ymin, zmin=bvh.zmin, xmax=bvh.xmax, ymax=bvh.ymax, zmax=bvh.zmax, bvh2bb=bvh.bvh2bb, left_child=bvh.left_child, right_child=bvh.right_child)
CSV.write(bvhfn, df, delim=" ")
end
function read_bvh(bvhfn::AbstractString)
# bvhfn is the full path (and filename) of the BVH
df = CSV.read(bvhfn, DataFrame) #delim=" ")
xmin::Array{Float64}, ymin::Array{Float64}, zmin::Array{Float64}, xmax::Array{Float64}, ymax::Array{Float64}, zmax::Array{Float64} = convert(Array{Float64}, df.xmin), convert(Array{Float64}, df.ymin), convert(Array{Float64}, df.zmin), convert(Array{Float64}, df.xmax), convert(Array{Float64}, df.ymax), convert(Array{Float64}, df.zmax)
bvh2bb::Array{Int}, right_child::Array{Int}, left_child::Array{Int} = convert(Array{Int}, df.bvh2bb), convert(Array{Int}, df.right_child), convert(Array{Int}, df.left_child)
bvh = Bvh{Float64, Int, Array{Float64,1}, Array{Int,1}}(xmin, ymin, zmin, xmax, ymax, zmax, bvh2bb, left_child, right_child)
return Bvh(xmin, ymin, zmin, xmax, ymax, zmax, bvh2bb, left_child, right_child)
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 1506 | function make_sky(light_pos::A, power::Integer, ambient::T, diffusePortion::T) where {T<:AbstractFloat, A<:AbstractArray{T,1}}
skymap::AbstractArray{T,2} = zeros(3600, 900)
azi::T = 0
zen::T = 0
for i=1:3600
for j=1:900
azi = float(i)/1800.0*pi
zen = float(j)/1800.0*pi
xi, yi, zi = spherical2carthesian(azi, zen)
skymap[i,j] = background_radiance([xi, yi, zi], light_pos, power, ambient, diffusePortion)
end
end
return skymap
end
function background_radiance(hemi_sample::Vector{T}, light_pos::Vector{T}, power::Int, ambient::T, diffusePortion) where {T<:AbstractFloat}
# expand this function with sun position, atmospheric model, etc.
direct::T = max(0.0, dot(light_pos, hemi_sample))^power
diffuse::T = max(0.0, dot(light_pos, hemi_sample))^1
directPortion::T = 1. - diffusePortion
dirrad::T = directPortion * direct
diffrad::T = diffusePortion * diffuse
radiance::T = (1.0-ambient) * (dirrad + diffrad) + ambient
return radiance
end
function sample_skymap(skymap::AbstractArray{T, 2}, dx::T, dy::T, dz::T) where {T<:AbstractFloat}
phi::T, theta::T = carthesian2spherical(dx, dy, dz)
v::T = phi*1800.0/pi # convert to an index...
i::Int = round(Int, v)
w::T = theta*1800.0/pi
j::Int = round(Int, w)
if i === 0
i = 1
elseif i > 3600
i = 3600
end
if j === 0
j = 1
elseif j > 900
j = 900
end
radiance::T = skymap[i, j]
return radiance
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 12430 |
function trace_back(geometry::Geometry{T,S,A,E}, shaders::Vector{Function}, ray::Ray{T}, nBands::S, maxNumberOfCycles::S) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
# traces ray/photon for rendering
count_while_loop = 0
continue_iterating::Bool = true
radiance::Vector{T} = ones(nBands) .* GREAT_NUM
mtl::Int = 0
hit::Bool = false
while continue_iterating
count_while_loop += 1
if count_while_loop >= maxNumberOfCycles
continue_iterating = false
continue
end
hit_, In, eidx, nrml, rmin = intersect(geometry, ray)
if hit_ === true
hit = true
mtl = geometry.mtl[eidx]
scatter, ray, r = shaders[mtl](In.x, In.y, In.z, -ray.dx, -ray.dy, -ray.dz, nrml.x, nrml.y, nrml.z)
radiance .*= r
if scatter === false
continue_iterating = false
end
else
radiance .*= 0.0
continue_iterating = false
end
end
return hit, radiance
end
function trace_back(geometry::Geometry{T,S,A,E}, geometry_bvh::Bvh{T,S,A,E}, shaders::Vector{Function}, ray::Ray{T}, nBands::S, maxNumberOfCycles::S) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
# traces ray/photon for rendering
count_while_loop = 0
continue_iterating::Bool = true
radiance::Vector{T} = ones(nBands) .* GREAT_NUM
mtl::Int = 0
hit::Bool = false
while continue_iterating
count_while_loop += 1
if count_while_loop >= maxNumberOfCycles
continue_iterating = false
continue
end
hit_, In, eidx, nrml, rmin = intersect(geometry, geometry_bvh, ray)
if hit_ === true
hit = true
mtl = geometry.mtl[eidx]
scatter, ray, r = shaders[mtl](In.x, In.y, In.z, -ray.dx, -ray.dy, -ray.dz, nrml.x, nrml.y, nrml.z)
radiance .*= r
if scatter === false
continue_iterating = false
end
else
radiance .*= 0.0
continue_iterating = false
end
end
return hit, radiance
end
function trace_back(geometry::Geometry{T,S,A,E}, shaders::Vector{Function}, skymap::B, ray::Ray{T}, nBands::S, maxNumberOfCycles::S) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, B<:AbstractArray{T,2}, E<:AbstractArray{S,1}}
# traces ray/photon for rendering
count_while_loop = 0
continue_iterating::Bool = true
radiance::Vector{T} = ones(nBands) .* GREAT_NUM
mtl::Int = 0
hit::Bool = false
while continue_iterating
count_while_loop += 1
if count_while_loop >= maxNumberOfCycles
continue_iterating = false
continue
end
hit_, In, eidx, nrml, rmin = intersect(mesh, ray)
if hit_mesh === true
hit = true
mtl = geometry.mtl[eidx]
scatter, ray, r = shaders[mtl](In.x, In.y, In.z, -ray.dx, -ray.dy, -ray.dz, nrml.x, nrml.y, nrml.z)
radiance .*= r
if scatter === false
continue_iterating = false
end
else
radiance .*= sample_skymap(skymap, ray.dx, ray.dy, ray.dz)
continue_iterating = false
end
end
return hit, radiance
end
function trace_back(geometry::Geometry{T,S,A,E}, geometry_bvh::Bvh{T,S,A,E}, shaders::Vector{Function}, skymap::B, ray::Ray{T}, nBands::S, maxNumberOfCycles::S) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, B<:AbstractArray{T,2}, E<:AbstractArray{S,1}}
# traces ray/photon for rendering
count_while_loop = 0
continue_iterating::Bool = true
radiance::Vector{T} = ones(nBands) .* GREAT_NUM
mtl::Int = 0
hit::Bool = false
while continue_iterating
count_while_loop += 1
if count_while_loop >= maxNumberOfCycles
continue_iterating = false
continue
end
hit_, In, eidx, nrml, rmin = intersect(geometry, geometry_bvh, ray)
if hit_ === true
hit = true
mtl = geometry.mtl[eidx]
scatter, ray, r = shaders[mtl](In.x, In.y, In.z, -ray.dx, -ray.dy, -ray.dz, nrml.x, nrml.y, nrml.z)
radiance .*= r
if scatter === false
continue_iterating = false
end
else
radiance .*= sample_skymap(skymap, ray.dx, ray.dy, ray.dz)
continue_iterating = false
end
end
return hit, radiance
end
function trace_back(assets::AbstractArray{Asset{T,S},1}, geometries::AbstractArray{Geometry{T,S,A,E},1}, palettes::AbstractArray{Vector{Function},1}, geometry_bvhs::AbstractArray{Bvh{T,S,A,E},1}, scene_bvh::Bvh{T,S,A,E}, ray::Ray{T}, skymap::B, nBands::S, maxNumberOfCycles::S) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, B<:AbstractArray{T,2}, E<:AbstractArray{S,1}}
# traces ray/photon for rendering
count_while_loop::S = 0
continue_iterating::Bool = true
radiance::Vector{T} = ones(nBands)
hit::Bool = false
while continue_iterating
count_while_loop += 1
if count_while_loop >= maxNumberOfCycles
continue_iterating = false
continue
end
hit_scene, I_scene, tray, nrml, range_scene, aidx, oidx, eidx = intersect_scene(assets, geometries, geometry_bvhs, scene_bvh, ray)
if hit_scene === true
hit = true
mtl = geometries[oidx].mtl[eidx]
pidx = assets[aidx].pidx
shader = palettes[pidx][mtl]
scatter, ray, r = shader(I_scene.x, I_scene.y, I_scene.z, -tray.dx, -tray.dy, -tray.dz, nrml.x, nrml.y, nrml.z)
radiance .*= r
if scatter === false
continue_iterating = false
end
else
radiance = radiance .* sample_skymap(skymap, ray.dx, ray.dy, ray.dz)
continue_iterating = false
end
end
return radiance
end
function render_pixel(coord::Coord{S}, geometry::Geometry{T,S,A,E}, shaders::Vector{Function}, camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
# check possible speed-ups by preallocating temporary arrays...
xr::T = 0.0
xrxIV::Vector{T} = [0.0, 0.0, 0.0]
yr::T = 0.0
yryIV::Vector{T} = [0.0, 0.0, 0.0]
radiance::Vector{T} = zeros(camera.nBands)
for i = 1:camera.nRaysPerPixel
xr = coord.x + rand()
xrxIV = xr .* camera.xIncVector
yr = coord.y + rand()
yryIV = yr .* camera.yIncVector
viewPlanePoint = camera.viewPlaneBottomLeftPoint .+ xrxIV .+ yryIV
dx, dy, dz = viewPlanePoint .- camera.eyePoint
ray = Ray(camera.eyePoint[1], camera.eyePoint[2], camera.eyePoint[3], dx, dy, dz)
hit, r = trace_back(geometry, shaders, ray, camera.nBands, camera.maxNumberOfCycles)
radiance = radiance .+ r
end
n::T = camera.nRaysPerPixel
radiance = radiance ./ n
return radiance
end
function render_pixel(coord::Coord{S}, geometry::Geometry{T,S,A,E}, shaders::Vector{Function}, skymap::B, camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, B<:AbstractArray{T,2}, E<:AbstractArray{S,1}}
# check possible speed-ups by preallocating temporary arrays...
xr::T = 0.0
xrxIV::Vector{T} = [0.0, 0.0, 0.0]
yr::T = 0.0
yryIV::Vector{T} = [0.0, 0.0, 0.0]
radiance::Vector{T} = zeros(camera.nBands)
for i = 1:camera.nRaysPerPixel
xr = coord.x + rand()
xrxIV = xr .* camera.xIncVector
yr = coord.y + rand()
yryIV = yr .* camera.yIncVector
viewPlanePoint = camera.viewPlaneBottomLeftPoint .+ xrxIV .+ yryIV
dx, dy, dz = viewPlanePoint .- camera.eyePoint
ray = Ray(camera.eyePoint[1], camera.eyePoint[2], camera.eyePoint[3], dx, dy, dz)
hit, r = trace_back(geometry, shaders, skymap, ray, camera.nBands, camera.maxNumberOfCycles)
radiance = radiance .+ r
end
n::T = camera.nRaysPerPixel
radiance = radiance ./ n
return radiance
end
function render_pixel(coord::Coord{S}, geometry::Geometry{T,S,A,E}, geometry_bvh::Bvh{T,S,A,E}, shaders::Vector{Function}, camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
# check possible speed-ups by preallocating temporary arrays...
xr::T = 0.0
xrxIV::Vector{T} = [0.0, 0.0, 0.0]
yr::T = 0.0
yryIV::Vector{T} = [0.0, 0.0, 0.0]
radiance::Vector{T} = zeros(camera.nBands)
for i = 1:camera.nRaysPerPixel
xr = coord.x + rand()
xrxIV = xr .* camera.xIncVector
yr = coord.y + rand()
yryIV = yr .* camera.yIncVector
viewPlanePoint = camera.viewPlaneBottomLeftPoint .+ xrxIV .+ yryIV
dx, dy, dz = viewPlanePoint .- camera.eyePoint
ray = Ray(camera.eyePoint[1], camera.eyePoint[2], camera.eyePoint[3], dx, dy, dz)
hit, r = trace_back(geometry, geometry_bvh, shaders, ray, camera.nBands, camera.maxNumberOfCycles)
radiance = radiance .+ r
end
n::T = camera.nRaysPerPixel
radiance = radiance ./ n
return radiance
end
function render_pixel(coord::Coord{S}, assets::AbstractArray{Asset{T,S},1}, geometries::AbstractArray{Geometry{T,S,A,E},1}, palettes::AbstractArray{Vector{Function},1}, geometry_bvhs::AbstractArray{Bvh{T,S,A,E},1}, scene_bvh::Bvh{T,S,A,E}, skymap::B, camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, B<:AbstractArray{T,2}, E<:AbstractArray{S,1}}
# check possible speed-ups by preallocating temporary arrays...
radiance::Vector{T} = zeros(camera.nBands)
for i = 1:camera.nRaysPerPixel
xr = coord.x + rand()
xrxIVx = xr * camera.xIncVector[1]
xrxIVy = xr * camera.xIncVector[2]
xrxIVz = xr * camera.xIncVector[3]
yr = coord.y + rand()
yryIVx = yr * camera.yIncVector[1]
yryIVy = yr * camera.yIncVector[2]
yryIVz = yr * camera.yIncVector[3]
viewPlanePointx = camera.viewPlaneBottomLeftPoint[1] + xrxIVx + yryIVx
viewPlanePointy = camera.viewPlaneBottomLeftPoint[2] + xrxIVy + yryIVy
viewPlanePointz = camera.viewPlaneBottomLeftPoint[3] + xrxIVz + yryIVz
dx = viewPlanePointx - camera.eyePoint[1]
dy = viewPlanePointy - camera.eyePoint[2]
dz = viewPlanePointz - camera.eyePoint[3]
ray = Ray(camera.eyePoint[1], camera.eyePoint[2], camera.eyePoint[3], dx, dy, dz)
radiance .+= trace_back(assets, geometries, palettes, geometry_bvhs, scene_bvh, ray, skymap, camera.nBands, camera.maxNumberOfCycles)
end
n::T = camera.nRaysPerPixel
radiance = radiance ./ n
return radiance
end
# although these render_image functions can be used fine to produce the right results, pmap
# is not that quick in this case... It is better to use @sync @distributed in combination with
# SharedArrays, like shown in the testRenderingWytham jupyter notebook...
function render_image(geometry::Geometry{T,S,A,E}, shaders::Vector{Function}, camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
coords = create_coords(camera)
img = @showprogress pmap(coord -> render_pixel(coord, geometry, shaders, camera), coords)
return img
end
function render_image(geometry::Geometry{T,S,A,E}, shaders::Vector{Function}, skymap::B, camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, B<:AbstractArray{T,2}, E<:AbstractArray{S,1}}
coords = create_coords(camera)
img = @showprogress pmap(coord -> render_pixel(coord, geometry, shaders, skymap, camera), coords)
return img
end
function render_image(geometry::Geometry{T,S,A,E}, geometry_bvh::Bvh{T,S,A,E}, shaders::Vector{Function}, camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
coords = create_coords(camera)
img = @showprogress pmap(coord -> render_pixel(coord, geometry, geometry_bvh, shaders, camera), coords)
return img
end
function render_image(assets::AbstractArray{Asset{T,S},1}, geometries::AbstractArray{Geometry{T,S,A,E},1}, palette::AbstractArray{Vector{Function},1}, geometry_bvhs::AbstractArray{Bvh{T,S,A,E},1}, scene_bvh::Bvh{T,S,A,E}, skymap::B, camera::Camera{T,S,A}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, B<:AbstractArray{T,2}, E<:AbstractArray{S,1}}
coords = create_coords(camera)
img = @showprogress pmap(coord -> render_pixel(coord, assets, geometries, palette, geometry_bvhs, scene_bvh, skymap, camera), coords)
return img
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 3606 | function load_scene_data(scene_full_path::AbstractString)
labels = Int[]
X = Float64[]
Y = Float64[]
Z = Float64[]
B = Float64[]
G = Float64[]
L = Int[]
asset_names = String[]
skymap_name = "nothing"
assets_fn = "nothing"
optic_name = "nothing"
println( string("Opening scene file: ", scene_full_path, " ..."))
open(scene_full_path) do f
for line in eachline(f)
if length(line) > 1
if occursin("//", line)
continue
elseif occursin("#", line)
label, asset_name = split(line, ",")
labels = push!(labels, parse(Int, label[2:end]) )
asset_names = push!(asset_names, asset_name)
elseif occursin("@", line)
assets_fn = split(line, ",")[2]
elseif occursin("*", line)
skymap_name = split(line, ",")[2]
elseif occursin("&", line)
optic_name = split(line, ",")[2]
else
x_, y_, z_, beta_, gamma_, label_ = split(line, ",")
x, y, z = parse(Float64, x_), parse(Float64, y_), parse(Float64, z_)
beta, gamma = parse(Float64, beta_), parse(Float64, gamma_)
l = round(Int, parse(Float64, label_))
X = push!(X, x)
Y = push!(Y, y)
Z = push!(Z, z)
B = push!(B, beta)
G = push!(G, gamma)
L = push!(L, l)
end
end
end
end
return skymap_name, optic_name, assets_fn, labels, asset_names, L, X, Y, Z, B, G
end
function read_scene(scene_name::AbstractString)
scene_full_path = string(scenefolder, scene_name, ".jay")
skymap_name, optic_name, assets_fn, asset_labels, asset_names, asset_idx, x, y, z, beta, gamma = load_scene_data(scene_full_path)
# load assets...
xml_path = string(assetfolder, assets_fn, ".xml")
xdoc = parse_file(xml_path)
xroot = LightXML.root(xdoc)
unique_mesh_names, mesh_idx, unique_palette_names, palette_idx = get_assets(xroot, asset_names)
asset2mesh_idx = mesh_idx[asset_idx]
asset2palette_idx = palette_idx[asset_idx]
n = length(x)
assets = Asset{Float64, Int}[]
for i=1:n
push!(assets, Asset(x[i], y[i], z[i], beta[i], gamma[i], asset2mesh_idx[i], asset2palette_idx[i]))
end
# load mesh data...
meshes::Array{Mesh{Float64, Int, Array{Float64,1}, Array{Int64,1}},1} = []
mesh_bvhs::Array{Bvh{Float64, Int, Array{Float64,1}, Array{Int64,1}},1} = []
for mesh_name in unique_mesh_names
mesh = read_mesh(mesh_name)
bvh = read_bvh(mesh_name)
meshes = push!(meshes, mesh)
mesh_bvhs = push!(mesh_bvhs, bvh)
end
# load scene bvh (or make it if necessary)...
if !isfile( string(bvhfolder, scene_name, ".bvh") )
make_bvh(assets, meshes, mesh_bvhs)
end
scene_bvh::Bvh{Float64, Int, Array{Float64,1}, Array{Int,1}} = read_bvh(scene_name)
# load the camera...
camera = read_camera(optic_name)
# read the skymap (optional, only if specified in scene description file)...
skymap_path = string(skyfolder, skymap_name, ".csv")
skymap = readdlm(skymap_path, ',', Float64)
# load materials/shaders...
palettes = Vector{Function}[]
for palette_name in unique_palette_names
xmlfn = string(palettefolder, palette_name, ".xml")
shaders = load_shaders(xmlfn ; assert_nBands=camera.nBands) # shaders, or palette, is of type: Vector{Function}
palettes = push!(palettes, shaders)
end
return assets, meshes, palettes, mesh_bvhs, scene_bvh, skymap, camera
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 5546 | #########################################################################################################
#
# The following shader functions have inputs that are all in the form (vx, vy, vz, nx, ny, nz, args...)
#
#########################################################################################################
#######################################################
#
# Photon shaders... (i.e. single waveband)
#
#######################################################
function lambertian_shader(Ix::T, Iy::T, Iz::T, vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; rho::T) where {T<:AbstractFloat}
# note that vx, vy, and vz are not used but only exist so that input arguments are of the same pattern as in other shader functions...
t, p = sample_f() # could be replaced with a function RPVSampler if we knew how to implement importance sampling for RPV...
fx, fy, fz = spherical2carthesian(t, p)
sx, sy, sz = project2normal(fx, fy, fz, nx, ny, nz)
newray = propagate(Ix, Iy, Iz, sx, sy, sz)
return true, newray, rho
end
function bilambertian_shader(Ix::T, Iy::T, Iz::T, vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; rho::T, tau::T) where {T<:AbstractFloat}
# note that vx, vy, and vz are not used but only exist so that input arguments are of the same pattern as in other shader functions...
l = rho + tau
r::Float64
if rand() > (rho/l)
nx, ny, nz = -1.0*nx, -1.0*ny, -1.0*nz
r = tau
else
r = rho
end
t, p = sample_f() # could be replaced with a function RPVSampler if we knew how to implement importance sampling for RPV...
fx, fy, fz = spherical2carthesian(t, p)
sx, sy, sz = project2normal(fx, fy, fz, nx, ny, nz)
newray = propagate(Ix, Iy, Iz, sx, sy, sz)
return true, newray, r
end
function pure_reflection_shader(vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; rho::T) where {T<:AbstractFloat}
sx, sy, sz = pure_reflection(vx, vy, vz, nx, ny, nz)
newray = propagate(Ix, Iy, Iz, sx, sy, sz)
return true, newray, rho
end
function rpv_shader(vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; rho_zero::T, rho_c::T, captheta::T, k::T) where {T<:AbstractFloat}
t, p = sample_f() # could be replaced with a function RPVSampler if we knew how to implement importance sampling for RPV...
fx, fy, fz = spherical2carthesian(t, p)
sx, sy, sz = project2world(fx, fy, fz, nx, ny, nz)
phi = relazi(vn, vy, vz, nx, ny, nz, sx, sy, sz)
theta = acos(vx*nx + vy*ny + vz*nz)
theta_zero = acos(sx*nx + sy*ny + sz*nz)
rho_sfc = rpv(theta_zero, theta, phi, rho_zero, rho_c, captheta, k)
newray = propagate(Ix, Iy, Iz, sx, sy, sz)
return true, newray, rho_sfc
end
###############################################################
#
# Path shaders... (i.e. acting on spectra)
#
###############################################################
function lambertian_path_shader(Ix::T, Iy::T, Iz::T, vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; rho::Array{T}) where {T<:AbstractFloat}
# note that vx, vy, and vz are not used but only exist so that input arguments are of the same pattern as in other shader functions...
t, p = sample_f() # could be replaced with a function RPVSampler if we knew how to implement importance sampling for RPV...
fx, fy, fz = spherical2carthesian(t, p)
sx, sy, sz = project2normal(fx, fy, fz, nx, ny, nz)
newray = propagate(Ix, Iy, Iz, sx, sy, sz)
r = rho * cos(t)
return true, newray, r
end
function bilambertian_path_shader(Ix::T, Iy::T, Iz::T, vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; rho::Array{T}, tau::Array{T}) where {T<:AbstractFloat}
# note that vx, vy, and vz are not used but only exist so that input arguments are of the same pattern as in other shader functions...
# note also that the whole spectrum undergoes one treatment: either reflect or transmit (obviously.)
l = rho + tau
r = 0.0
if rand() > (sum(rho)/sum(l))
nx, ny, nz = -1.0*nx, -1.0*ny, -1.0*nz
r = tau
else
r = rho
end
t, p = sample_f() # could be replaced with a function RPVSampler if we knew how to implement importance sampling for RPV...
fx, fy, fz = spherical2carthesian(t, p)
sx, sy, sz = project2normal(fx, fy, fz, nx, ny, nz)
newray = propagate(Ix, Iy, Iz, sx, sy, sz)
r = r * cos(t)
return true, newray, r
end
function rpv_path_shader(Ix::T, Iy::T, Iz::T, vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; rho_zero::Array{T}, rho_c::Array{T}, captheta::Array{T}, k::Array{T}) where {T<:AbstractFloat}
t, p = sample_f() # could be replaced with a function RPVSampler if we knew how to implement importance sampling for RPV...
fx, fy, fz = spherical2carthesian(t, p)
sx, sy, sz = project2normal(fx, fy, fz, nx, ny, nz)
phi = relazi(vx, vy, vz, nx, ny, nz, sx, sy, sz)
theta = acos(vx*nx + vy*ny + vz*nz)
theta_zero = acos(sx*nx + sy*ny + sz*nz)
rho_sfc = rpv(theta_zero, theta, phi, rho_zero, rho_c, captheta, k)
newray = propagate(Ix, Iy, Iz, sx, sy, sz)
return true, newray, rho_sfc
end
function pure_reflection_path_shader(Ix::T, Iy::T, Iz::T, vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; rho::Array{T}) where {T<:AbstractFloat}
sx, sy, sz = pure_reflection(vx, vy, vz, nx, ny, nz)
newray = propagate(Ix, Iy, Iz, sx, sy, sz)
return true, newray, rho
end
function lightsource_path_shader(Ix::T, Iy::T, Iz::T, vx::T, vy::T, vz::T, nx::T, ny::T, nz::T ; emission::Array{T}) where {T<:AbstractFloat}
return false, Ray(Ix, Iy, Iz, vx, vy, vz), emission
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 12978 |
import LinearAlgebra:normalize
function normalize(x::T, y::T, z::T) where {T<:Real}
l::T = sqrt( *(x, x) + *(y, y) + *(z, z) )
xn::T = x / l
yn::T = y / l
zn::T = z / l
return xn, yn, zn
end
struct Asset{T<:AbstractFloat, S<:Integer}
xoff::T
yoff::T
zoff::T
beta::T
gamma::T
oidx::S
pidx::S
end
struct Bvh{T<:AbstractFloat, S<:Integer, A<:AbstractArray, E<:AbstractArray}
xmin::A
ymin::A
zmin::A
xmax::A
ymax::A
zmax::A
bvh2bb::E
left_child::E
right_child::E
Bvh{T,S,A,E}(a::AbstractArray{T,1}, b::AbstractArray{T,1}, c::AbstractArray{T,1}, d::AbstractArray{T,1}, e::AbstractArray{T,1}, f::AbstractArray{T,1}, p::AbstractArray{S}, q::AbstractArray{S}, r::AbstractArray{S}) where {T,S,A,E} = new(a,b,c,d,e,f,p,q,r)
end
Bvh(a::AbstractArray, b::AbstractArray, c::AbstractArray, d::AbstractArray, e::AbstractArray, f::AbstractArray, p::AbstractArray, q::AbstractArray, r::AbstractArray) = Bvh{eltype(a), eltype(p), typeof(a), typeof(p)}(a,b,c,d,e,f,p,q,r)
struct Camera{T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}}
eyePoint::A
lookAtPoint::A
fov::T
xResolution::S
yResolution::S
nBands::S
nRaysPerPixel::S
maxNumberOfCycles::S
# derived attributes
viewDirection::A
u::A
w::A
aspectRatio::T
viewPlaneHalfHeight::T
viewPlaneHalfWidth::T
viewPlaneBottomLeftPoint::A
xIncVector::A
yIncVector::A
function Camera{T,S,A}(eyePoint::A, lookAtPoint::A, fov::T, xResolution::S, yResolution::S, nBands::S, nRaysPerPixel::S, maxNumberOfCycles::S) where {T,S,A}
viewDirection = LinearAlgebra.normalize(lookAtPoint .- eyePoint)
u = LinearAlgebra.normalize(cross(LinearAlgebra.normalize([0.000000, 0.000001, 1.0]), viewDirection))
w = LinearAlgebra.normalize(cross(u, viewDirection))
viewPlaneHalfWidth = tan(fov/2.0)
aspectRatio = float(yResolution) / float(xResolution)
viewPlaneHalfHeight = aspectRatio .* viewPlaneHalfWidth
viewPlaneBottomLeftPoint = (eyePoint .+ viewDirection) .- (w .* viewPlaneHalfHeight) .- (u .* viewPlaneHalfWidth)
xIncVector = (u .* 2.0 .* viewPlaneHalfWidth) ./ float(xResolution)
yIncVector = (w .* 2.0 .* viewPlaneHalfHeight) ./ float(yResolution)
new(eyePoint, lookAtPoint, fov, xResolution, yResolution, nBands, nRaysPerPixel, maxNumberOfCycles, viewDirection, u, w, aspectRatio, viewPlaneHalfHeight, viewPlaneHalfWidth, viewPlaneBottomLeftPoint, xIncVector, yIncVector)
end
end
Camera(v::A, w::A, p::T, q::S, r::S, s::S, t::S, u::S) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray} = Camera{T,S,A}(v,w,p,q,r,s,t,u)
struct Coord{S<:Integer}
x::S
y::S
end
abstract type Geometry{T<:AbstractFloat, S<:Integer, A<:AbstractArray, E<:AbstractArray} end
struct Ball{T,S,A,E} <: Geometry{T,S,A,E}
p1x::A
p1y::A
p1z::A
r::A
rsq::A
mtl::E
function Ball{T,S,A,E}(p::AbstractArray{T,2}, radius::AbstractArray{T,1}, mtl::AbstractArray{S,1}) where {T,S,A,E}
n_balls = size(p, 1)
p1x::Array{T, 1} = p[:,1]
p1y::Array{T, 1} = p[:,2]
p1z::Array{T, 1} = p[:,3]
r::Array{T, 1} = radius
rsq::Array{T, 1} = radius.^2
mtl::Array{S, 1} = mtl
new(p1x, p1y, p1z, r, rsq, mtl)
end
end
Ball(p::AbstractArray{T,2}, radius::AbstractArray{T,1}, mtl::AbstractArray{S,1}) where {T<:AbstractFloat, S<:Integer} = Ball{eltype(p), eltype(mtl), Array{T,1}, Array{S,1}}(p,radius,mtl)
struct Disk{T,S,A,E} <: Geometry{T,S,A,E}
p1x::A
p1y::A
p1z::A
nx::A
ny::A
nz::A
r::A
rsq::A
mtl::E
function Disk{T,S,A,E}(p::AbstractArray{T,2}, n::AbstractArray{T,2}, radius::AbstractArray{T,1}, mtl::AbstractArray{S,1}) where {T,S,A,E}
n_disks = size(p, 1)
p1x::Array{T, 1} = p[:,1]
p1y::Array{T, 1} = p[:,2]
p1z::Array{T, 1} = p[:,3]
nx::Array{T, 1} = n[:,1]
ny::Array{T, 1} = n[:,2]
nz::Array{T, 1} = n[:,3]
r::Array{T, 1} = radius
rsq::Array{T, 1} = radius.^2
mtl::Array{S, 1} = mtl
new(p1x, p1y, p1z, nx, ny, nz, r, rsq, mtl)
end
end
Disk(p::AbstractArray{T,2}, n::AbstractArray{T,2}, radius::AbstractArray{T,1}, mtl::AbstractArray{S,1}) where {T<:AbstractFloat, S<:Integer} = Disk{eltype(p), eltype(mtl), Array{T,1}, Array{S,1}}(p,n,radius,mtl)
struct Cylinder{T,S,A,E} <: Geometry{T,S,A,E}
m1x::A
m1y::A
m1z::A
m2x::A
m2y::A
m2z::A
radius::A
u::A
v::A
w::A
length::A
beta::A
gamma::A
rsq::A
mtl::E
function Cylinder{T,S,A,E}(m::AbstractArray{T,2}, l::AbstractArray{S,2}, radius::AbstractArray{T,1}, mtl::AbstractArray{S,1}) where {T,S,A,E}
n_cylinders = size(l, 1)
m1x::Array{T, 1} = zeros(n_cylinders)
m1y::Array{T, 1} = zeros(n_cylinders)
m1z::Array{T, 1} = zeros(n_cylinders)
m2x::Array{T, 1} = zeros(n_cylinders)
m2y::Array{T, 1} = zeros(n_cylinders)
m2z::Array{T, 1} = zeros(n_cylinders)
radius::Array{T, 1} = radius
u::Array{T, 1} = zeros(n_cylinders)
v::Array{T, 1} = zeros(n_cylinders)
w::Array{T, 1} = zeros(n_cylinders)
length::Array{T, 1} = zeros(n_cylinders)
beta::Array{T, 1} = zeros(n_cylinders)
gamma::Array{T, 1} = zeros(n_cylinders)
rsq::Array{T, 1} = zeros(n_cylinders)
mtl::Array{S, 1} = mtl
for i = 1:n_cylinders
idx1 = l[i,1]; idx2 = l[i,2]
m1x[i] = m[idx1,1]; m1y[i] = m[idx1,2]; m1z[i] = m[idx1,3]
m2x[i] = m[idx2,1]; m2y[i] = m[idx2,2]; m2z[i] = m[idx2,3]
dx = m[idx2,1] - m[idx1,1]
dy = m[idx2,2] - m[idx1,2]
dz = m[idx2,3] - m[idx1,3]
length_ = sqrt(dx^2 + dy^2 + dz^2)
length[i] = length_
beta[i] = acos(dz / length_)
gamma[i] = atan(dy, dx) # formerly atan2
rsq[i] = radius[i]^2
# compute a 'normal' vector that is pointing up
q = [dx, dy, dz]
nv = normalize(cross([0.0034, 0.0071, 1.0], q))
vq = cross(nv, q)
u[i] = vq[1]
v[i] = vq[2]
w[i] = vq[3]
end
new(m1x, m1y, m1z, m2x, m2y, m2z, radius, u, v, w, length, beta, gamma, rsq, mtl)
end
end
Cylinder(m::AbstractArray{T,2}, l::AbstractArray{S,2}, radius::AbstractArray{T,1}, mtl::AbstractArray{S,1}) where {T<:AbstractFloat, S<:Integer} = Cylinder{eltype(m), eltype(l), Array{T,1}, Array{S,1}}(m,l,radius,mtl)
struct Cone{T,S,A,E} <: Geometry{T,S,A,E}
m1x::A
m1y::A
m1z::A
m2x::A
m2y::A
m2z::A
radius_base::A
radius_tip::A
u::A
v::A
w::A
beta::A
gamma::A
length::A
a::A
aa::A
r1a::A
r1sq::A
mtl::E
function Cone{T,S,A,E}(m::AbstractArray{T,2}, l::AbstractArray{S,2}, radius_base::AbstractArray{T,1}, radius_tip::AbstractArray{T,1}, mtl::AbstractArray{S,1}) where {T,S,A,E}
n_cones = size(l, 1)
m1x::Array{T, 1} = zeros(n_cones)
m1y::Array{T, 1} = zeros(n_cones)
m1z::Array{T, 1} = zeros(n_cones)
m2x::Array{T, 1} = zeros(n_cones)
m2y::Array{T, 1} = zeros(n_cones)
m2z::Array{T, 1} = zeros(n_cones)
radius_base::Array{T, 1} = radius_base
radius_tip::Array{T, 1} = radius_tip
u::Array{T, 1} = zeros(n_cones)
v::Array{T, 1} = zeros(n_cones)
w::Array{T, 1} = zeros(n_cones)
beta::Array{T, 1} = zeros(n_cones)
gamma::Array{T, 1} = zeros(n_cones)
length::Array{T, 1} = zeros(n_cones)
a::Array{T, 1} = zeros(n_cones)
aa::Array{T, 1} = zeros(n_cones)
r1a::Array{T, 1} = zeros(n_cones)
r1sq::Array{T, 1} = zeros(n_cones)
mtl::Array{S, 1} = mtl
for i = 1:n_cones
idx1 = l[i,1]; idx2 = l[i,2]
m1x[i] = m[idx1,1]; m1y[i] = m[idx1,2]; m1z[i] = m[idx1,3]
m2x[i] = m[idx2,1]; m2y[i] = m[idx2,2]; m2z[i] = m[idx2,3]
dx = m[idx2,1] - m[idx1,1]
dy = m[idx2,2] - m[idx1,2]
dz = m[idx2,3] - m[idx1,3]
length_ = sqrt(dx^2 + dy^2 + dz^2)
length[i] = length_
beta[i] = acos(dz / length_)
gamma[i] = atan(dy, dx) # formerly atan2
a_ = (radius_tip[i] - radius_base[i]) / length_ # taper of the stem
a[i] = a_
aa[i] = a_^2
r1a[i] = radius_base[i]*a_
r1sq[i] = radius_base[i]^2
# compute a 'normal' vector that is pointing up
q = [dx, dy, dz]
nv = normalize(cross([0.0034, 0.0071, 1.0], q))
vq = cross(nv, q)
u[i] = vq[1]
v[i] = vq[2]
w[i] = vq[3]
end
new(m1x, m1y, m1z, m2x, m2y, m2z, radius_base, radius_tip, u, v, w, beta, gamma, length, a, aa, r1a, r1sq, mtl)
end
end
Cone(m::AbstractArray{T,2}, l::AbstractArray{S,2}, radius_base::AbstractArray{T,1}, radius_tip::AbstractArray{T,1}, mtl::AbstractArray{S,1}) where {T<:AbstractFloat, S<:Integer} = Cone{eltype(m), eltype(l), Array{T,1}, Array{S,1}}(m,l,radius_base,radius_tip,mtl)
struct Mesh{T,S,A,E} <: Geometry{T,S,A,E}
v1x::A
v1y::A
v1z::A
v2x::A
v2y::A
v2z::A
v3x::A
v3y::A
v3z::A
mtl::E
ux::A
uy::A
uz::A
wx::A
wy::A
wz::A
nx::A
ny::A
nz::A
uu::A
uw::A
ww::A
D::A
function Mesh{T,S,A,E}(v::AbstractArray{T, 2}, t::AbstractArray{S, 2}, m::AbstractArray{S, 1}) where {T,S,A,E}
n_triangles = size(t, 1)
v1x::Array{T, 1} = zeros(n_triangles)
v1y::Array{T, 1} = zeros(n_triangles)
v1z::Array{T, 1} = zeros(n_triangles)
v2x::Array{T, 1} = zeros(n_triangles)
v2y::Array{T, 1} = zeros(n_triangles)
v2z::Array{T, 1} = zeros(n_triangles)
v3x::Array{T, 1} = zeros(n_triangles)
v3y::Array{T, 1} = zeros(n_triangles)
v3z::Array{T, 1} = zeros(n_triangles)
mtl::Array{S, 1} = m
ux::Array{T, 1} = zeros(n_triangles)
uy::Array{T, 1} = zeros(n_triangles)
uz::Array{T, 1} = zeros(n_triangles)
wx::Array{T, 1} = zeros(n_triangles)
wy::Array{T, 1} = zeros(n_triangles)
wz::Array{T, 1} = zeros(n_triangles)
nx::Array{T, 1} = zeros(n_triangles)
ny::Array{T, 1} = zeros(n_triangles)
nz::Array{T, 1} = zeros(n_triangles)
uu::Array{T, 1} = zeros(n_triangles)
uw::Array{T, 1} = zeros(n_triangles)
ww::Array{T, 1} = zeros(n_triangles)
D::Array{T, 1} = zeros(n_triangles)
for i = 1:n_triangles
idx1 = t[i,1]; idx2 = t[i,2]; idx3 = t[i,3]
v1x[i] = v[idx1,1]; v1y[i] = v[idx1,2]; v1z[i] = v[idx1,3]
v2x[i] = v[idx2,1]; v2y[i] = v[idx2,2]; v2z[i] = v[idx2,3]
v3x[i] = v[idx3,1]; v3y[i] = v[idx3,2]; v3z[i] = v[idx3,3]
# precompute some variables...
ux_ = v2x[i] - v1x[i]
uy_ = v2y[i] - v1y[i]
uz_ = v2z[i] - v1z[i]
wx_ = v3x[i] - v1x[i]
wy_ = v3y[i] - v1y[i]
wz_ = v3z[i] - v1z[i]
u_ = [ux_, uy_, uz_]
w_ = [wx_, wy_, wz_]
n_ = cross(u_, w_)
n2_ = n_.^2
sm_ = sum(n2_)
l_ = sqrt(sm_)
n_ = n_./l_
uu_ = dot(u_, u_)
uw_ = dot(u_, w_)
ww_ = dot(w_, w_)
uw2_ = (uw_ * uw_)
uuww_ = (uu_ * ww_)
D_ = uw2_ - uuww_
ux[i] = ux_
uy[i] = uy_
uz[i] = uz_
wx[i] = wx_
wy[i] = wy_
wz[i] = wz_
nx[i] = n_[1]
ny[i] = n_[2]
nz[i] = n_[3]
uu[i] = uu_
uw[i] = uw_
ww[i] = ww_
D[i] = D_
end
new(v1x, v1y, v1z, v2x, v2y, v2z, v3x, v3y, v3z, mtl, ux, uy, uz, wx, wy, wz, nx, ny, nz, uu, uw, ww, D)
end
end
Mesh(v::AbstractArray{T,2}, t::AbstractArray{S,2}, m::AbstractArray{S,1}) where {T<:AbstractFloat, S<:Integer} = Mesh{eltype(v), eltype(t), Array{T,1}, Array{S,1}}(v,t,m)
struct Point{T<:AbstractFloat}
x::T
y::T
z::T
end
struct Ray{T<:AbstractFloat}
x::T
y::T
z::T
dx::T
dy::T
dz::T
end
struct Hook{T<:AbstractFloat, S<:Integer}
xoff::T
yoff::T
zoff::T
beta::T
gamma::T
idx::S
Hook{T,S}(x::T, y::T, z::T, beta::T, gamma::T, idx::S) where {T,S} = new(x,y,z,beta,gamma,idx)
end
Hook(x::AbstractFloat, y::AbstractFloat, z::AbstractFloat, beta::AbstractFloat, gamma::AbstractFloat, idx::Integer) = Hook{typeof(x), typeof(idx)}(x,y,z,beta,gamma,idx)
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 6384 | function translate_ray(ray::Ray{T}, xoff::T, yoff::T, zoff::T) where {T<:AbstractFloat}
x = ray.x + xoff
y = ray.y + yoff
z = ray.z + zoff
tray = Ray(x, y, z, ray.dx, ray.dy, ray.dz)
return tray
end
function transform_tzy(ray::Ray{T}, xoff::T, yoff::T, zoff::T, beta::T, gamma::T) where {T<:AbstractFloat}
# to transform from world space into object space
# (values for xoff, yoff, ..., gamma, should be of opposite sign to how they are defined in the scene specification file)
# the translation
x = ray.x + xoff
y = ray.y + yoff
z = ray.z + zoff
# rotate about z-axis
x_ = x * cos(gamma) + y * -sin(gamma)
y = x * sin(gamma) + y * cos(gamma)
dx_ = ray.dx * cos(gamma) + ray.dy * -sin(gamma)
dy = ray.dx * sin(gamma) + ray.dy * cos(gamma)
# rotate about y-axis
x = x_ * cos(beta) + z * sin(beta)
z = x_ * -sin(beta) + z * cos(beta)
dx = dx_ * cos(beta) + ray.dz * sin(beta)
dz = dx_ * -sin(beta) + ray.dz * cos(beta)
tray = Ray(x, y, z, dx, dy, dz)
return tray
end
function carthesian2spherical(x::T, y::T, z::T) where {T<:AbstractFloat}
theta = atan(sqrt(x*x + y*y), z)
phi = atan(x, y)
if phi < 0.0
phi += 2.0*pi
end
return theta, phi
end
function spherical2carthesian(theta::T, phi::T) where {T<:AbstractFloat}
x = sin(theta) * sin(phi)
y = sin(theta) * cos(phi)
z = cos(theta)
return x, y, z
end
function relazi(vx::T, vy::T, vz::T, nx::T, ny::T, nz::T, sx::T, sy::T, sz::T) where {T<:AbstractFloat}
# v=viewVector; n=normalVector; h=halfVector...
ux, uy, uz = cross_scalars(nx, ny, nz, sx, sy, sz)
vx, vy, vz = cross_scalars(nx, ny, nz, vx, vy, vz)
nsx, nsy, nsz = normalize_scalars(ux, uy, uz)
nvx, nvy, nvz = normalize_scalars(vx, vy, vz)
a = acos( nsx*nvx + nsy*nvy + nsz*nvz )
return a
end
function get_extremes(x::Vector{T}, y::Vector{T}, z::Vector{T}) where {T<:AbstractFloat}
minx, maxx = minimum(x), maximum(x)
miny, maxy = minimum(y), maximum(y)
minz, maxz = minimum(z), maximum(z)
p::Vector{T} = [minx, minx, minx, minx, maxx, maxx, maxx, maxx]
q::Vector{T} = [miny, miny, maxy, maxy, miny, miny, maxx, maxx]
r::Vector{T} = [minz, maxz, minz, maxz, minz, maxz, minz, maxz]
return p, q, r
end
function get_extremes(geometry::Geometry{T,S,Array{T,1},Array{S,1}}) where {T<:AbstractFloat, S<:Integer}
x = vcat(geometry.v1x, geometry.v2x, geometry.v3x)
y = vcat(geometry.v1y, geometry.v2y, geometry.v3y)
z = vcat(geometry.v1z, geometry.v2z, geometry.v3z)
p, q, r = get_extremes(x, y, z)
return p, q, r
end
function get_extremes(geometry::Geometry{T,S,A,E}, hook::Hook{T,S}) where {T<:AbstractFloat, S<:Integer, A<:AbstractArray{T,1}, E<:AbstractArray{S,1}}
x, y, z = get_extremes(geometry)
x, y, z = transform_forward(x, y, z, hook)
x, y, z = get_extremes(x, y, z)
return x, y, z
end
function transform(x::T, y::T, z::T, xoff::T, yoff::T, zoff::T, beta::T, gamma::T) where {T<:AbstractFloat}
# to transform x,y,z from object space into worldspace
# rotate about y-axis
t = x * cos(beta) + z * sin(beta)
c = x * -sin(beta) + z * cos(beta)
# rotate about z-axis
a = t * cos(gamma) + y * -sin(gamma)
b = t * sin(gamma) + y * cos(gamma)
# and the translation
a = a + xoff
b = b + yoff
c = c + zoff
return a, b, c
end
function translate_forward(x::T, y::T, z::T, hook::Hook{T,S}) where {T<:AbstractFloat, S<:Integer}
x = x + hook.xoff
y = y + hook.yoff
z = z + hook.zoff
return x, y, z
end
function translate_inverse(x::T, y::T, z::T, hook::Hook{T,S}) where {T<:AbstractFloat, S<:Integer}
x = x - hook.xoff
y = y - hook.yoff
z = z - hook.zoff
return x, y, z
end
function translate_forward(x::AbstractArray{T}, y::AbstractArray{T}, z::AbstractArray{T}, hook::Hook{T,S}) where {T<:AbstractFloat, S<:Integer}
x = x .+ hook.xoff
y = y .+ hook.yoff
z = z .+ hook.zoff
return x, y, z
end
function translate_inverse(x::AbstractArray{T}, y::AbstractArray{T}, z::AbstractArray{T}, hook::Hook{T,S}) where {T<:AbstractFloat, S<:Integer}
x = x .- hook.xoff
y = y .- hook.yoff
z = z .- hook.zoff
return x, y, z
end
function rotate_forward(x::T, y::T, z::T, hook::Hook{T,S}) where {T <: AbstractFloat, S<:Integer}
# rotate about y-axis
nx_ = x * cos(hook.beta) + z * sin(hook.beta)
nz = x * -1.0 * sin(hook.beta) + z * cos(hook.beta)
# rotate about z-axis
nx = nx_ * cos(hook.gamma) + y * -1.0 * sin(hook.gamma)
ny = nx_ * sin(hook.gamma) + y * cos(hook.gamma)
return nx, ny, nz
end
function rotate_forward(x::AbstractArray{T}, y::AbstractArray{T}, z::AbstractArray{T}, hook::Hook{T,S}) where {T <: AbstractFloat, S<:Integer}
# rotate about y-axis
nx_ = x .* cos(hook.beta) .+ z .* sin(hook.beta)
nz = x .* -1.0 .* sin(hook.beta) .+ z .* cos(hook.beta)
# rotate about z-axis
nx = nx_ .* cos(hook.gamma) .+ y .* -1.0 .* sin(hook.gamma)
ny = nx_ .* sin(hook.gamma) .+ y .* cos(hook.gamma)
return nx, ny, nz
end
function rotate_inverse(x::T, y::T, z::T, hook::Hook{T,S}) where {T<:AbstractFloat, S<:Integer}
inv_beta = -1.0 * hook.beta
inv_gamma = -1.0 * hook.gamma
# rotate about z-axis (to get segment tip on y=0 plane)
nx_1 = x * cos(inv_gamma) + y * -1.0 * sin(inv_gamma)
ny = x * sin(inv_gamma) + y * cos(inv_gamma)
# rotate about y-axis (to get segment tip on z=0 plane)
nx = nx_1 * cos(inv_beta) + z * sin(inv_beta)
nz = nx_1 * -1.0 * sin(inv_beta) + z * cos(inv_beta)
return nx, ny, nz
end
function transform_forward(x::AbstractArray{T}, y::AbstractArray{T}, z::AbstractArray{T}, hook::Hook{T,S}) where {T<:AbstractFloat, S<:Integer}
x, y, z = rotate_forward(x, y, z, hook)
x, y, z = translate_forward(x, y, z, hook)
return x, y, z
end
function transform_inverse(ray::Ray{T}, hook::Hook{T,S}) where {T<:AbstractFloat, S<:Integer}
x, y, z = translate_inverse(ray.x, ray.y, ray.z, hook)
x, y, z = rotate_inverse(x, y, z, hook)
dx, dy, dz = rotate_inverse(ray.dx, ray.dy, ray.dz, hook)
transRay::Ray = Ray(x, y, z, dx, dy, dz)
return transRay
end
function weibull(x, a, b)
y = (a/b) .* (x./b).^(a-1) .* exp.(.-(x./b).^a)
ys = y ./ maximum(y)
return y, ys
end
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | code | 493 |
using Test
using RenderJay
this_fn = @__FILE__
this_folder, _ = splitdir(this_fn)
scene_fn = joinpath(this_folder, "testplot_little_cornellboxes.xml")
println("Reading data...")
assets, geometries, palettes, geometry_bvhs, scene_bvh, skymap, camera = read_scene(scene_fn)
coords = create_coords(camera)
println("Testing the render_pixel() function...")
radiance = render_pixel(coords[1], assets, geometries, palettes, geometry_bvhs, scene_bvh, skymap, camera)
@test all(radiance .> 0.0)
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 0.1.0 | 364a3d192933d5d9b1c70c69d103181002b2dee1 | docs | 3652 | # RenderJay.jl
a Julia-based path tracer
RenderJay is a Julia-based path tracer that was intended for operation on large compute clusters, with applications in ecology and remote sensing where scenes are characterized by very high polygon counts and lots of detail, but not so much for applications in computer graphics. For example, RenderJay uses no bump maps or textures; everything is down to geometry and bidirectional reflectance (transmittance) distribution functions (BRDFs, BTDFs). Being written
in Julia it can profit from Julia's distributed computing capabilities, enabling processing of large workloads across multiple servers.
RenderJay can be installed as follows from the Julia REPL:
```
using Pkg
Pkg.add("RenderJay")
```
# Usage
The following is an example code for rendering. It will produce a top-down view of four Cornell boxes in different colours, floating above a gray flat surface. Produced renderings can be found in img/ The surface geometry, downwelling irradiance, as well as the scene specification (XML) file with the shaders can all be found under test/
The Wytham Woods image is an example rendering that was derived from data that was provided through the RAdiative transfer Model Intercomparison (RAMI) phase-V, that can be found here:
https://rami-benchmark.jrc.ec.europa.eu/_www/phase_descr.php?strPhase=RAMI5
(feel free to contact author for conversion scripts to Jay format)
If you are on a laptop or you have few logical cores, please mind the addprocs() line below and set the number to something comfortable, e.g., the number of logical cores that are available.
# Performance indication
Rendering a 512x512px image of the below Cornell boxes scene took 00:34:04 (HH:MM:SS) on the Dell T7910 (DUAL E5-2630V3) using 30 workers and it took 3:39:20 (HH:MM:SS) on a Lenovo Edge 15 laptop (i7-4510U) with only 3 workers...
# Example code
Below is an example that renders a set of four Cornell boxes with different colours floating just above a flat surface.
```
using Distributed
addprocs(3)
@everywhere using RenderJay
using CSV, LightXML, DataFrames, DelimitedFiles, LinearAlgebra, ProgressMeter, SharedArrays, ImageMagick, Images
pth = pathof(RenderJay)
src_folder, _ = splitdir(pth)
root_folder = src_folder[1:end-3]
scene_fn = joinpath(root_folder, "test/testplot_little_cornellboxes.xml")
assets, geometries, palettes, geometry_bvhs, scene_bvh, skymap, camera = read_scene(scene_fn);
coords = create_coords(camera);
img = SharedArray{Float64, 3}(camera.nBands, camera.xResolution, camera.yResolution);
@time @sync @distributed for coord in coords[1:nprocs()]
img[:, coord.x, coord.y] = render_pixel(coord, assets, geometries, palettes, geometry_bvhs, scene_bvh, skymap, camera)
end
npixels = length(coords)
blocksize = camera.xResolution
@showprogress for i=1:blocksize:npixels
e = min(i+blocksize, npixels)
@sync @distributed for coord in coords[i:e]
img[:, coord.x, coord.y] = render_pixel(coord, assets, geometries, palettes, geometry_bvhs, scene_bvh, skymap, camera)
end
end
```
You can save the rendering to disk as follows:
```
using ImageMagick, Images
img3 = reshape(hcat(img...), camera.nBands, camera.xResolution, camera.yResolution)
mn, mx = minimum(img3), maximum(img3)
imscl = img3 ./ (mx/1.0)
imscl .*= 10.0
msk = imscl .> 1.0
imscl[msk] .= 1.0
im = colorview(RGB, imscl)
save("/tmp/test_little_cornell_boxes.tif", im')
a = 1.5
b = 10.0
_, imwb = weibull(imscl, a, b)
im2 = colorview(RGB, imwb)
save("/tmp/test_little_cornell_boxes_wb.tif", im2')
```
| RenderJay | https://github.com/martinvanleeuwen/RenderJay.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 1121 | module DeepDiffs
export deepdiff, added, removed, changed, before, after
export SimpleDiff, VectorDiff, StringDiff, DictDiff
# Helper function for comparing two instances of a type for equality by field
function fieldequal(x::T, y::T) where T
for f in fieldnames(T)
getfield(x, f) == getfield(y, f) || return false
end
true
end
hascolor(io::IO) = get(IOContext(io), :color, false)
"""
diff = deepdiff(obj1, obj2)
deepdiff computes the structural difference between two objects and returns
a diff representing "edits" needed to transform obj1 into obj2. This diff
supports the `added`, `removed`, and `modified` functions that return `Set`s of
dictionary keys or array indices.
"""
function deepdiff end
abstract type DeepDiff end
# fallback diff that just stores two values
struct SimpleDiff{T1, T2} <: DeepDiff
before::T1
after::T2
end
Base.:(==)(lhs::SimpleDiff, rhs::SimpleDiff) = fieldequal(lhs, rhs)
before(d::SimpleDiff) = d.before
after(d::SimpleDiff) = d.after
deepdiff(x, y) = SimpleDiff(x, y)
include("arrays.jl")
include("dicts.jl")
include("strings.jl")
end # module
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 3728 | struct VectorDiff{T1, T2} <: DeepDiff
before::T1
after::T2
removed::Vector{Int}
added::Vector{Int}
end
before(diff::VectorDiff) = diff.before
after(diff::VectorDiff) = diff.after
removed(diff::VectorDiff) = diff.removed
added(diff::VectorDiff) = diff.added
changed(diff::VectorDiff) = Int[]
Base.:(==)(d1::VectorDiff, d2::VectorDiff) = fieldequal(d1, d2)
# diffing an array is an application of the Longest Common Subsequence problem:
# https://en.wikipedia.org/wiki/Longest_common_subsequence_problem
function deepdiff(X::Vector, Y::Vector)
# we're going to solve with dynamic programming, so let's first pre-allocate
# our result array, which will store possible lengths of the common
# substrings.
lengths = zeros(Int, length(X)+1, length(Y)+1)
for (j, v2) in enumerate(Y)
for (i, v1) in enumerate(X)
if v1 == v2
lengths[i+1, j+1] = lengths[i, j] + 1
else
lengths[i+1, j+1] = max(lengths[i+1, j], lengths[i, j+1])
end
end
end
removed = Int[]
added = Int[]
backtrack(lengths, removed, added, X, Y, length(X), length(Y))
VectorDiff(X, Y, removed, added)
end
# recursively trace back the longest common subsequence, adding items
# to the added and removed lists as we go
function backtrack(lengths, removed, added, X, Y, i, j)
if i > 0 && j > 0 && X[i] == Y[j]
backtrack(lengths, removed, added, X, Y, i-1, j-1)
elseif j > 0 && (i == 0 || lengths[i+1, j] ≥ lengths[i, j+1])
backtrack(lengths, removed, added, X, Y, i, j-1)
push!(added, j)
elseif i > 0 && (j == 0 || lengths[i+1, j] < lengths[i, j+1])
backtrack(lengths, removed, added, X, Y, i-1, j)
push!(removed, i)
end
end
# takes a function to be called for each item. The arguments given to the function
# are the items index, the state of the item (:removed, :added, :same) and a boolean
# for whether it's the last item. Indices are given for the `before` array when
# the state is :removed or :same, and for the `after` array when it's :added.
function visitall(f::Function, diff::VectorDiff)
from = before(diff)
to = after(diff)
rem = removed(diff)
add = added(diff)
ifrom = 1
ito = 1
iremoved = 1
iadded = 1
while ifrom <= length(from) || ito <= length(to)
if iremoved <= length(rem) && ifrom == rem[iremoved]
ifrom += 1
iremoved += 1
f(ifrom-1, :removed, ifrom > length(from) && ito > length(to))
elseif iadded <= length(add) && ito == add[iadded]
ito += 1
iadded += 1
f(ito-1, :added, ifrom > length(from) && ito > length(to))
else
# not removed or added, must be in both
ifrom += 1
ito += 1
f(ifrom-1, :same, ifrom > length(from) && ito > length(to))
end
end
end
function Base.show(io::IO, diff::VectorDiff)
from = before(diff)
to = after(diff)
rem = removed(diff)
add = added(diff)
print(io, "[")
visitall(diff) do idx, state, last
if state == :removed
printitem(io, from[idx], :red, "(-)")
last || printstyled(io, ", ", color=:red)
elseif state == :added
printitem(io, to[idx], :green, "(+)")
last || printstyled(io, ", ", color=:green)
else
printitem(io, from[idx])
last || print(io, ", ")
end
end
print(io, "]")
end
# prefix is printed if we're not using color
function printitem(io, v, color=:normal, prefix="")
if hascolor(io)
printstyled(io, v, color=color)
else
print(io, prefix, v)
end
end
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 3582 | struct DictDiff{T1, KT1, T2, KT2} <: DeepDiff
before::T1
after::T2
removed::Set{KT1}
added::Set{KT2}
changed::Dict{KT1, DeepDiff}
unchanged::Set{KT1}
end
before(diff::DictDiff) = diff.before
after(diff::DictDiff) = diff.after
removed(diff::DictDiff) = diff.removed
added(diff::DictDiff) = diff.added
changed(diff::DictDiff) = diff.changed
Base.:(==)(lhs::DictDiff, rhs::DictDiff) = fieldequal(lhs, rhs)
function deepdiff(X::AbstractDict, Y::AbstractDict)
xkeys = Set(keys(X))
ykeys = Set(keys(Y))
bothkeys = intersect(xkeys, ykeys)
removed = setdiff(xkeys, ykeys)
added = setdiff(ykeys, xkeys)
unchanged = Set{eltype(bothkeys)}()
changed = Dict{eltype(bothkeys), DeepDiff}()
for key in bothkeys
if X[key] != Y[key]
changed[key] = deepdiff(X[key], Y[key])
else
push!(unchanged, key)
end
end
DictDiff(X, Y, removed, added, changed, unchanged)
end
Base.show(io::IO, diff::DictDiff) = diffprint(io, diff, 0)
# indentation space
const inspace = " "
function diffprint(io, d::DictDiff, indent=0)
bef = before(d)
aft = after(d)
println(io, "Dict(")
for k in d.unchanged
# extra space to account for added linemarker
print(io, " ", inspace ^ (indent+1))
prettyprint(io, Pair(k, bef[k]), " ", indent+1)
println(io, ",")
end
Base.with_output_color(:red, io) do io
for k in removed(d)
print(io, "-", inspace ^ (indent+1))
prettyprint(io, Pair(k, bef[k]), "-", indent+1)
println(io, ",")
end
end
for (k, v) in changed(d)
if isa(v, SimpleDiff)
# if we have a key pointing to a SimpleDiff, then we don't know how to
# deconstruct the value, so instead we print it like a removed and added key
Base.with_output_color(:red, io) do io
print(io, "-", inspace ^ (indent+1))
prettyprint(io, Pair(k, before(v)), "-", indent+1)
println(io, ",")
end
Base.with_output_color(:green, io) do io
print(io, "+", inspace ^ (indent+1))
prettyprint(io, Pair(k, after(v)), "+", indent+1)
println(io, ",")
end
else
# extra space to account for added linemarker
print(io, " ", inspace ^ (indent+1))
prettyprint(io, Pair(k, v), " ", indent+1)
println(io, ",")
end
end
Base.with_output_color(:green, io) do io
for k in added(d)
print(io, "+", inspace ^ (indent+1))
prettyprint(io, Pair(k, aft[k]), "+", indent+1)
println(io, ",")
end
end
# don't print the leading space if we're at the top-level
print(io, indent == 0 ? "" : " ")
print(io, inspace ^ indent, ")")
end
function prettyprint(io, d::AbstractDict, linemarker, indent)
println(io, "Dict(")
for p in d
print(io, linemarker, inspace ^ (indent+1))
prettyprint(io, p, linemarker, indent+1)
println(io, ",")
end
print(io, linemarker, inspace ^ indent, ")")
end
function prettyprint(io, p::Pair, linemarker, indent)
prettyprint(io, p[1], linemarker, indent)
print(io, " => ")
prettyprint(io, p[2], linemarker, indent)
end
function prettyprint(io, p::Pair{<:Any, <:DictDiff}, linemarker, indent)
prettyprint(io, p[1], linemarker, indent)
print(io, " => ")
diffprint(io, p[2], indent)
end
prettyprint(io, x, linemarker, indent) = show(io, x)
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 2851 | # used for single-line strings
struct StringDiff{T1, T2} <: DeepDiff
before::T1
after::T2
diff::VectorDiff
end
# used for multi-line strings
struct StringLineDiff{T1, T2} <: DeepDiff
before::T1
after::T2
diff::VectorDiff
end
function deepdiff(X::AbstractString, Y::AbstractString)
if occursin("\n", X) || occursin("\n", Y)
# we'll compare hashes of each line rather than the text itself, because
# these comparisons are done many times
xhashes = map(hash, split(X, '\n'))
yhashes = map(hash, split(Y, '\n'))
StringLineDiff(X, Y, deepdiff(xhashes, yhashes))
else
StringDiff(X, Y, deepdiff(collect(X), collect(Y)))
end
end
const AllStringDiffs = Union{StringDiff, StringLineDiff}
before(diff::AllStringDiffs) = diff.before
after(diff::AllStringDiffs) = diff.after
added(diff::AllStringDiffs) = added(diff.diff)
removed(diff::AllStringDiffs) = removed(diff.diff)
changed(diff::AllStringDiffs) = []
Base.:(==)(d1::T, d2::T) where {T<:AllStringDiffs} = fieldequal(d1, d2)
function Base.show(io::IO, diff::StringLineDiff)
xlines = split(diff.before, '\n')
ylines = split(diff.after, '\n')
println(io, "\"\"\"")
visitall(diff.diff) do idx, state, last
if state == :removed
printstyled(io, "- ", escape_string(xlines[idx]), color=:red)
elseif state == :added
printstyled(io, "+ ", escape_string(ylines[idx]), color=:green)
else
print(io, " ", escape_string(xlines[idx]))
end
if last
print(io, "\"\"\"")
else
println(io)
end
end
end
function Base.show(io::IO, diff::StringDiff)
xchars = before(diff.diff)
ychars = after(diff.diff)
laststate = :init
print(io, "\"")
visitall(diff.diff) do idx, state, last
if !hascolor(io)
# check to see if we need to close a block
if laststate == :removed && state != :removed
print(io, "-}")
elseif laststate == :added && state != :added
print(io, "+}")
end
# check to see if we need to open a block
if laststate != :removed && state == :removed
print(io, "{-")
elseif laststate != :added && state == :added
print(io, "{+")
end
end
if state == :removed
printstyled(io, string(xchars[idx]), color=:red)
elseif state == :added
printstyled(io, string(ychars[idx]), color=:green)
else
print(io, xchars[idx])
end
laststate = state
end
if !hascolor(io)
if laststate == :removed
print(io, "-}")
elseif laststate == :added
print(io, "+}")
end
end
print(io, "\"")
end
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 1056 | @testset "arrays can be diffed" begin
a1 = [1, 2, 3, 4]
# one number changed
a2 = [1, 7, 3, 4]
d = deepdiff(a1, a2)
@test added(d) == [2]
@test removed(d) == [2]
@test changed(d) == []
@test before(d) == a1
@test after(d) == a2
# removed from middle
d = deepdiff(a1, [1, 3, 4])
@test removed(d) == [2]
@test added(d) == []
# removed from beginning
d = deepdiff(a1, [2, 3, 4])
@test removed(d) == [1]
@test added(d) == []
# removed from end
d = deepdiff(a1, [1, 2, 3])
@test removed(d) == [4]
@test added(d) == []
# added to end
d = deepdiff(a1, [1, 2, 3, 4, 5])
@test removed(d) == []
@test added(d) == [5]
# added to beginning
d = deepdiff(a1, [0, 1, 2, 3, 4])
@test removed(d) == []
@test added(d) == [1]
# two additions
d = deepdiff(a1, [1, 4, 2, 5, 3, 4])
@test removed(d) == []
@test added(d) == [2, 4]
# two removals
d = deepdiff(a1, [2, 4])
@test removed(d) == [1, 3]
@test added(d) == []
end
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 2297 | @testset "Dicts can be diffed" begin
d1 = Dict(
:foo => "foo",
:bar => "bar",
:baz => Dict(
:fizz => "fizz",
:buzz => "buzz"
)
)
@testset "One Changed" begin
d = deepdiff(d1, Dict(
:foo => "foo",
:bar => "biz",
:baz => Dict(
:fizz => "fizz",
:buzz => "buzz"
)
))
@test added(d) == Set()
@test removed(d) == Set()
@test changed(d) == Dict{Symbol, DeepDiffs.DeepDiff}(:bar => deepdiff("bar", "biz"))
end
@testset "One Removed" begin
d = deepdiff(d1, Dict(
:foo => "foo",
:baz => Dict(
:fizz => "fizz",
:buzz => "buzz"
)
))
@test added(d) == Set()
@test removed(d) == Set([:bar])
@test changed(d) == Dict()
end
@testset "One Added" begin
d = deepdiff(d1, Dict(
:foo => "foo",
:bar => "bar",
:biz => "biz",
:baz => Dict(
:fizz => "fizz",
:buzz => "buzz"
)
))
@test added(d) == Set([:biz])
@test removed(d) == Set()
@test changed(d) == Dict()
end
@testset "Inner Dict Modified" begin
d = deepdiff(d1, Dict(
:foo => "foo",
:bar => "bar",
:baz => Dict(
:fizz => "fizz",
:buzz => "bizzle"
)
))
@test added(d) == Set()
@test removed(d) == Set()
@test changed(d) == Dict{Symbol, DeepDiffs.DeepDiff}(:baz => deepdiff(
Dict(
:fizz => "fizz",
:buzz => "buzz"
),
Dict(
:fizz => "fizz",
:buzz => "bizzle"
)
))
end
@testset "Totally Removed" begin
d = deepdiff(d1, Dict())
@test added(d) == Set()
@test removed(d) == Set([:foo, :bar, :baz])
@test changed(d) == Dict()
end
@testset "Totally added" begin
d = deepdiff(Dict(), d1)
@test added(d) == Set([:foo, :bar, :baz])
@test removed(d) == Set()
@test changed(d) == Dict()
end
end
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 5974 | @testset "Display tests" begin
# Return a stream with color set as specified. On 0.6 this requires setting
# a global flag, and the :color property in the IOContext has no effect.
function setcolor(yn::Bool)
IOContext(IOBuffer(), :color=>yn)
end
function resetcolor()
global orig_color
nothing
end
# check dictionary print output. This is a little complicated because
# the ordering isn't specified. To work around this we just split
# up both into lines and make sure they have the same lines in some ordering.
# This means we could possibly miss some errors, but it seems like a
# reasonable compomise
# expected should be a list of display lines within that dict
function checkdictprint(output, expected)
outlines = sort(split(output, "\n"))
explines = sort(split(expected, "\n"))
@test outlines == explines
end
@testset "Array diffs print correctly" begin
d1 = deepdiff([1, 2, 7, 3], [2, 3, 4, 1, 2, 3, 5])
d2 = deepdiff([1], [2])
buf = setcolor(true)
expected1 = """
[[32m2[39m[32m, [39m[32m3[39m[32m, [39m[32m4[39m[32m, [39m[0m1, [0m2, [31m7[39m[31m, [39m[0m3, [32m5[39m]"""
expected2 = """[[31m1[39m[31m, [39m[32m2[39m]"""
@testset "Color Diffs" begin
display(TextDisplay(buf), d1)
@test String(take!(buf.io)) == expected1
display(TextDisplay(buf), d2)
@test String(take!(buf.io)) == expected2
end
buf = setcolor(false)
@testset "No-Color Diffs" begin
display(TextDisplay(buf), d1)
@test String(take!(buf.io)) == """
[(+)2, (+)3, (+)4, 1, 2, (-)7, 3, (+)5]"""
display(TextDisplay(buf), d2)
@test String(take!(buf.io)) == """
[(-)1, (+)2]"""
end
resetcolor()
end
@testset "Dict diffs print correctly" begin
d = deepdiff(
Dict(
:a => "a",
:b => "b",
:c => "c",
:list => [1, 2, 3],
:dict1 => Dict(
:a => 1,
:b => 2,
:c => 3
),
:dict2 => Dict(
:a => 1,
:b => 2,
:c => 3
)
),
Dict(
:a => "a",
:b => "d",
:e => "e",
:list => [1, 4, 3],
:dict1 => Dict(
:a => 1,
:b => 2,
:c => 3
),
:dict2 => Dict(
:a => 1,
:c => 4
)
),
)
@testset "Color Diffs" begin
buf = setcolor(true)
display(TextDisplay(buf), d)
expected = """
Dict(
:a => "a",
:dict1 => Dict(
:c => 3,
:a => 1,
:b => 2,
),
[31m- :c => "c",
[39m :list => [[0m1, [31m2[39m[31m, [39m[32m4[39m[32m, [39m[0m3],
:b => "[31mb[39m[32md[39m",
:dict2 => Dict(
:a => 1,
[31m- :b => 2,
[39m[31m- :c => 3,
[39m[32m+ :c => 4,
[39m[32m[39m ),
[32m+ :e => "e",
[39m)"""
# This test is broken because the specifics of how the ANSI color
# codes are printed change based on the order, which changes with
# different julia versions.
@test_skip String(take!(buf.io)) == expected
end
@testset "No-Color Diffs" begin
buf = setcolor(false)
display(TextDisplay(buf), d)
expected = """
Dict(
:a => "a",
:dict1 => Dict(
:c => 3,
:a => 1,
:b => 2,
),
- :c => "c",
:list => [1, (-)2, (+)4, 3],
:b => "{-b-}{+d+}",
:dict2 => Dict(
:a => 1,
- :b => 2,
- :c => 3,
+ :c => 4,
),
+ :e => "e",
)"""
checkdictprint(String(take!(buf.io)), expected)
end
resetcolor()
end
@testset "single-line strings display correctly" begin
# this test is just to handle some cases that don't get exercised elsewhere
diff = deepdiff("abc", "adb")
buf = setcolor(false)
display(TextDisplay(buf), diff)
@test String(take!(buf.io)) == "\"a{+d+}b{-c-}\""
resetcolor()
end
@testset "Multi-line strings display correctly" begin
s1 = """
differences can
be hard to find
in
multiline
output"""
s2 = """
differences can
be hurd to find
multiline
output"""
diff = deepdiff(s1, s2)
@testset "Color Display" begin
buf = setcolor(true)
expected = """
\"\"\"
differences can
[31m- be hard to find[39m
[31m- in[39m
[32m+ be hurd to find[39m
multiline
output\"\"\""""
display(TextDisplay(buf), diff)
@test String(take!(buf.io)) == expected
end
@testset "No-Color Display" begin
buf = setcolor(false)
display(TextDisplay(buf), diff)
@test String(take!(buf.io)) == """
\"\"\"
differences can
- be hard to find
- in
+ be hurd to find
multiline
output\"\"\""""
end
resetcolor()
end
end
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 316 | using DeepDiffs
using Test
if isdefined(Base, :have_color)
# Capture the original state of the global flag
orig_color = Base.have_color
end
@testset "DeepDiff Tests" begin
include("arrays.jl")
include("dicts.jl")
include("display.jl")
include("simplediff.jl")
include("strings.jl")
end
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 81 | @testset "SimpleDiff tests" begin
@test deepdiff(1, 2) == deepdiff(1, 2)
end
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | code | 861 | @testset "Single-line Strings can be diffed" begin
@testset "bπiz -> bπaz" begin
s1 = "bπiz"
s2 = "bπaz"
diff = deepdiff(s1, s2)
@test before(diff) == s1
@test after(diff) == s2
# the indices are assuming a Vector of chars, like you'd get from `collect`
@test removed(diff) == [3]
@test added(diff) == [3]
@test changed(diff) == []
end
end
@testset "Multi-line Strings can be diffed" begin
s1 = """differences can
be hard to find
in
multiline
output"""
s2 = """differences can
be hurd to find
multiline
output"""
diff = deepdiff(s1, s2)
@test before(diff) == s1
@test after(diff) == s2
@test removed(diff) == [2, 3]
@test added(diff) == [2]
@test changed(diff) == []
end
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 1.2.0 | 9824894295b62a6a4ab6adf1c7bf337b3a9ca34c | docs | 3053 | # DeepDiffs
[](https://travis-ci.org/ssfrr/DeepDiffs.jl)
[](https://ci.appveyor.com/project/ssfrr/deepdiffs-jl/branch/master)
[](http://codecov.io/github/ssfrr/DeepDiffs.jl?branch=master)
DeepDiffs.jl provides the `deepdiff` function, which finds and displays differences (diffs) between Julia data structures. It supports `Vector`s, `Dict`s, and `String`s. When diffing dictionaries where values associated with a particular key may change, `deepdiff` will recurse into value to provide a more detailed diff.
Many users will likely only use the `deepdiff` function to interactively visualize diffs. For more advanced usage, the return value from `deepdiff` will be some subtype of the `DeepDiff` abstract type which can be further manipulated. These subtypes support the following functions:
* `before(diff)`: returns the first original (left-hand-side) value that was diffed
* `after(diff)`: returns the modified (right-hand-side) value that was diffed
* `added(diff)`: returns a list of indices or dictionary keys that were new items. These indices correspond to the "after" value.
* `removed(diff)`: returns a list of indices or dictionary keys that were removed. These indices correspond to the "before" value.
* `changed(diff)`: returns a dictionary whose keys are indices or dictionary keys and whose values are themselves `DeepDiff`s that describe the modified value. Currently this is only meaningful when diffing dictionaries because the keys can be matched up between the original and modified values.
## Diffing `Vector`s
`Vector`s are diffed using a longest-subsequence algorithm that tries to minmize the number of additions and removals necessary to transform one `Vector` to another.
## Diffing `Dict`s
`Dict`s are diffed by matching up the keys between the original and modified values, so it can recognize removed, added, or modified values.
If color is disabled then the additions and removals are displayed a little differently:
## Diffing `String`s
### Single-line strings
Single-line strings are diffed character-by-character. The indices returned by `added` and `removed` correspond to indices in the `Vector` of characters returned by `collect(str::String)`.
### Multi-line strings
Multi-line strings (strings with at least one newline) are diffed line-by-line. The indices returned by `added` and `removed` correspond to line numbers.
| DeepDiffs | https://github.com/ssfrr/DeepDiffs.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 528 | using Quantics
using Documenter
DocMeta.setdocmeta!(Quantics, :DocTestSetup, :(using Quantics); recursive=true)
makedocs(;
modules=[Quantics],
authors="Hiroshi Shinaoka <[email protected]> and contributors",
sitename="Quantics.jl",
format=Documenter.HTML(;
canonical="https://github.com/tensor4all/Quantics.jl",
edit_link="main",
assets=String[]),
pages=[
"Home" => "index.md"
])
deploydocs(;
repo="github.com/tensor4all/Quantics.jl.git",
devbranch="main"
)
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 567 | #__precompile__(false)
module Quantics
#@everywhere begin
#using Pkg
#Pkg.activate(".")
#Pkg.instantiate()
#end
using ITensors
import ITensors
import ITensors.NDTensors: Tensor, BlockSparseTensor, blockview
import SparseIR: Fermionic, Bosonic, Statistics
import LinearAlgebra: I
using StaticArrays
import FastMPOContractions
using EllipsisNotation
function __init__()
end
include("util.jl")
include("tag.jl")
include("binaryop.jl")
include("mul.jl")
include("mps.jl")
include("fouriertransform.jl")
include("imaginarytime.jl")
include("transformer.jl")
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 16807 | @doc raw"""
``a x + b y``, where ``a = 0, \pm 1`` and ``b = 0, \pm 1`` (``a + b \neq -2``).
```
out
|
--------
cin --| T |-- cout
--------
| |
x y
```
``T_{x, y, \mathrm{out}, \mathrm{cin}, \mathrm{cout}} = 1`` if ``a x + b y + \mathrm{cin} = \mathrm{cout}``, ``=0`` otherwise (`out` is the output bit).
"""
function _binaryop_tensor(a::Int, b::Int, site_x::Index{T}, site_y::Index{T},
site_out::Index{T},
cin_on::Bool, cout_on::Bool, bc::Int) where {T}
abs(a) <= 1 || error("a must be either 0, 1, -1")
abs(b) <= 1 || error("b must be either 0, 1, -1")
abs(bc) == 1 || error("bc must be either 1, -1")
a + b != -2 || error("a = -1 and b = -1 not supported")
cins = cin_on ? [-1, 0, 1] : [0]
cinsize = length(cins)
coutsize = cout_on ? 3 : 1
tensor = zeros(Float64, (cinsize, coutsize, 2, 2, 2))
for (idx_cin, cin) in enumerate(cins), y in 0:1, x in 0:1
res = a * x + b * y + cin
if res >= 0
cout = _getbit(abs(res), 1)
else
cout = -1
end
if cout_on
tensor[idx_cin, cout + 2, x + 1, y + 1, (abs(res) & 1) + 1] = 1
else
tensor[idx_cin, 1, x + 1, y + 1, (abs(res) & 1) + 1] = (cout == 0 ? 1 : bc)
end
end
link_in = Index(cinsize, "link_in")
link_out = Index(coutsize, "link_out")
return ITensor(tensor, [link_in, link_out, site_x, site_y, site_out]), link_in, link_out
end
"""
Create a tensor acting on a vector of sites.
"""
function binaryop_tensor_multisite(sites::Vector{Index{T}},
coeffs::Vector{Tuple{Int,Int}},
pos_sites_in::Vector{Tuple{Int,Int}},
cin_on::Bool,
cout_on::Bool,
bc::Vector{Int}) where {T<:Number}
# Check
sites = noprime.(sites)
nsites = length(sites)
length(coeffs) == nsites || error("Length of coeffs does not match that of coeffs")
length(pos_sites_in) == nsites ||
error("Length of pos_sites_in does not match that of coeffs")
sites_in = [Index(2, "site_dummy,n=$n") for n in eachindex(sites)]
links_in = Index{T}[]
links_out = Index{T}[]
# First, we need to know the number of dummny indices for each site.
ndumnyinds = zeros(Int, nsites)
for n in 1:nsites
for s in pos_sites_in[n]
ndumnyinds[s] += 1
end
end
res = ITensor(1)
for n in 1:nsites
res *= dense(delta(sites[n],
[setprime(sites_in[n], plev) for plev in 1:ndumnyinds[n]]))
end
currentdummyinds = ones(Int, nsites)
for n in 1:nsites
sites_ab = setprime(sites_in[pos_sites_in[n][1]],
currentdummyinds[pos_sites_in[n][1]]),
setprime(sites_in[pos_sites_in[n][2]],
currentdummyinds[pos_sites_in[n][2]])
for i in 1:2
currentdummyinds[pos_sites_in[n][i]] += 1
end
t, lin, lout = _binaryop_tensor(coeffs[n]..., sites_ab..., sites[n]',
cin_on, cout_on, bc[n])
push!(links_in, lin)
push!(links_out, lout)
res *= t
end
linkin = Index(prod(dim.(links_in)), "linkin")
linkout = Index(prod(dim.(links_out)), "linkout")
res = permute(res, [links_in..., links_out..., prime.(sites)..., sites...])
# Here, we swap sites and prime(sites)!
res = ITensor(ITensors.data(res), [linkin, linkout, sites..., prime.(sites)...])
return res
end
"""
Construct an MPO representing a selector associated with binary operations.
We describe the functionality for length(coeffs) = 2 (nsites_bop).
In this case, site indices are split into a list of chuncks of nsites_bop sites.
Binary operations are applied to each chunck and the direction of carry is forward (rev_carrydirec=true)
or backward (rev_carrydirec=false).
Assumed rev_carrydirec = true, we consider a two-variable g(x, y), which is quantized as
x = (x_1 ... x_R)_2, y = (y_1 ... y_R)_2.
We now define a new function by binary operations as
f(x, y) = g(a * x + b * y + s1, c * x + d * y + s2),
where a, b, c, d = +/- 1, 0, and s1, s1 are arbitrary integers.
`bc` is a vector of boundary conditions for each arguments of `g` (not of `f`).
"""
function affinetransform(M::MPS,
tags::AbstractVector{String},
coeffs_dic::AbstractVector{Dict{String,Int}},
shift::AbstractVector{Int},
bc::AbstractVector{Int};
kwargs...)
transformer = affinetransformmpo(siteinds(M), tags, coeffs_dic, shift, bc)
return apply(transformer, M; kwargs...)
end
function affinetransformmpo(sites::AbstractVector{Index{T}},
tags::AbstractVector{String},
coeffs_dic::AbstractVector{Dict{String,Int}},
shift::AbstractVector{Int},
bc::AbstractVector{Int})::MPO where {T}
# f(x, y) = g(a * x + b * y + s1, c * x + d * y + s2)
# = h(a * x + b * y, c * x + d * y),
# where h(x, y) = g(x + s1, y + s2).
# The transformation is executed in this order: g -> h -> f.
mpos = MPO[]
# Number of variables involved in transformation
ntransvars = length(tags)
2 <= ntransvars ||
error("Number of variables for transformation must be greater than or equal to 2.")
sites_for_tag = []
for tag in tags
push!(sites_for_tag, findallsites_by_tag(sites; tag=tag))
if length(sites_for_tag[end]) == 0
error("Tag $tag is not found.")
end
end
length(unique(map(length, sites_for_tag))) == 1 ||
error("Number of sites for each tag must be equal.")
length(shift) == ntransvars || error("Length of shift must be equal to that of tags.")
# If shift is required
if !all(shift .== 0)
for i in 1:ntransvars
push!(mpos, shiftaxismpo(sites, shift[i]; tag=tags[i], bc=bc[i]))
end
end
# Followed by a rotation
push!(mpos, affinetransformmpo(sites, tags, coeffs_dic, bc))
# Contract MPOs
res = mpos[1]
for n in 2:length(mpos)
res = apply(mpos[n], res; cutoff=1e-25, maxdim=typemax(Int))
end
return res
end
"""
Affine transform of a MPS with no shift
Significant bits are assumed to be aligned from left to right for all tags.
"""
function affinetransform(M::MPS,
tags::AbstractVector{String},
coeffs_dic::AbstractVector{Dict{String,Int}},
bc::AbstractVector{Int};
kwargs...)
transformer = affinetransformmpo(siteinds(M), tags, coeffs_dic, bc)
return apply(transformer, M; kwargs...)
end
"""
Generate an MPO representing an affine transform of a MPS with no shift
Significant bits are assumed to be aligned from left to right for all tags.
"""
function affinetransformmpo(sites::AbstractVector{Index{T}},
tags::AbstractVector{String},
coeffs_dic::AbstractVector{Dict{String,Int}},
bc::AbstractVector{Int})::MPO where {T}
mpos = MPO[]
# f(x, y) = g(a * x + b * y + s1, c * x + d * y + s2)
# = h(a * x + b * y, c * x + d * y),
# where h(x, y) = g(x + s1, y + s2).
# The transformation is taken place in this order: g -> h -> f.
# Number of variables involved in transformation
ntransvars = length(tags)
2 <= ntransvars ||
error("Number of variables for transformation must be greater than or equal to 2.")
sites_for_tag = []
for tag in tags
push!(sites_for_tag, findallsites_by_tag(sites; tag=tag))
if length(sites_for_tag[end]) == 0
error("Tag $tag is not found.")
end
end
length(unique(map(length, sites_for_tag))) == 1 ||
error("Number of sites for each tag must be equal.")
tags_to_pos = Dict(tag => i for (i, tag) in enumerate(tags))
all([length(c) == 2 for c in coeffs_dic]) ||
error("Length of each element in coeffs_dic must be 2")
coeffs = Tuple{Int,Int}[]
pos_sites_in = Tuple{Int,Int}[]
for inewval in 1:ntransvars
length(coeffs_dic[inewval]) == 2 ||
error("Length of each element in coeffs_dic must be 2: $(coeffs_dic[inewval])")
pos_sites_in_ = [tags_to_pos[t] for (t, c) in coeffs_dic[inewval]]
length(unique(pos_sites_in_)) == 2 ||
error("Each element of pos_sites_in must contain two different values: $(pos_sites_in_)")
all(pos_sites_in_ .>= 0) || error("Invalid tag: $(coeffs_dic[inewval])")
push!(pos_sites_in, Tuple(pos_sites_in_))
push!(coeffs, Tuple([c for (t, c) in coeffs_dic[inewval]]))
end
length(tags) == ntransvars || error("Length of tags does not match that of coeffs")
length(pos_sites_in) == ntransvars ||
error("Length of pos_sites_in does not match that of coeffs")
# Check if the order of significant bits is consistent among all tags
rev_carrydirecs = Bool[]
pos_for_tags = []
sites_for_tags = []
for i in 1:ntransvars
push!(sites_for_tags, findallsiteinds_by_tag(sites; tag=tags[i]))
pos_for_tag = findallsites_by_tag(sites; tag=tags[i])
push!(rev_carrydirecs, isascendingorder(pos_for_tag))
push!(pos_for_tags, pos_for_tag)
end
valid_rev_carrydirecs = all(rev_carrydirecs .== true) || all(rev_carrydirecs .== false)
valid_rev_carrydirecs ||
error("The order of significant bits must be consistent among all tags!")
#all(rev_carrydirecs .== true) ||
#error("Significant bits are aligned from left to right for all tags!")
length(unique([length(s) for s in sites_for_tags])) == 1 ||
error("The number of sites for each tag must be the same! $([length(s) for s in sites_for_tags])")
rev_carrydirec = all(rev_carrydirecs .== true) # If true, significant bits are at the left end.
if !rev_carrydirec
transformer_ = affinetransformmpo(
reverse(sites), reverse(tags), reverse(coeffs_dic), reverse(bc))
return MPO([transformer_[n] for n in reverse(1:length(transformer_))])
end
# First check transformations with -1 and -1; e.g., (a, b) = (-1, -1)
# These transformations are not supported in the backend.
# To support this case, we need to flip the sign of coeffs as follows:
# f(x, y) = h(x + y, c * x + d * y) = g(- x -y, c * x + d * y),
# where h(x, y) = g(-x, y).
# The transformation is taken place in this order: g -> h -> f.
sign_flips = [coeffs[n][1] == -1 && coeffs[n][2] == -1 for n in eachindex(coeffs)]
for v in 1:ntransvars
if sign_flips[v]
push!(mpos, bc[v] * reverseaxismpo(sites; tag=tags[v], bc=bc[v]))
end
end
# Apply binary operations (nomore (-1, -1) coefficients)
coeffs_positive = [(sign_flips[n] ? abs.(coeffs[n]) : coeffs[n])
for n in eachindex(coeffs)]
sites_mpo = collect(Iterators.flatten(Iterators.zip(sites_for_tags...)))
transformer = _binaryop_mpo(sites_mpo, coeffs_positive, pos_sites_in;
rev_carrydirec=true, bc=bc)
transformer = matchsiteinds(transformer, sites)
push!(mpos, transformer)
# Contract MPOs
res = mpos[1]
for n in 2:length(mpos)
res = apply(mpos[n], res; cutoff=1e-25, maxdim=typemax(Int))
end
return res
end
"""
Construct an MPO representing a selector associated with binary operations.
We describe the functionality for length(coeffs) = 2 (nsites_bop).
In this case, site indices are split into a list of chuncks of nsites_bop sites.
Binary operations are applied to each chunck and the direction of carry is forward (rev_carrydirec=true)
or backward (rev_carrydirec=false).
Assumed rev_carrydirec = true, we consider a two-variable g(x, y), which is quantized as
x = (x_1 ... x_R)_2, y = (y_1 ... y_R)_2.
We now define a new function by binary operations as
f(x, y) = g(a * x + b * y, c * x + d * y),
where a, b, c, d = +/- 1, 0, and s1, s1 are arbitrary integers.
The transform from `g` to `f` can be represented as an MPO:
f(x_1, y_1, ..., x_R, y_R) = M(x_1, y_1, ...; x'_1, y'_1, ...) f(x'_1, y'_1, ..., x'_R, y'_R).
The MPO `M` acts a selector: The MPO selects values from `f` to form `g`.
For rev_carrydirec = false, the returned MPO represents
f(x_R, y_R, ..., x_1, y_1) = M(x_R, y_R, ...; x'_R, y'_R, ...) f(x'_R, y'_R, ..., x'_1, y'_1).
`bc` is a vector of boundary conditions for each arguments of `g` (not of `f`).
"""
function _binaryop_mpo(sites::Vector{Index{T}},
coeffs::Vector{Tuple{Int,Int}},
pos_sites_in::Vector{Tuple{Int,Int}};
rev_carrydirec=false,
bc::Union{Nothing,Vector{Int}}=nothing) where {T<:Number}
# Number of variables involved in transformation
nsites_bop = length(coeffs)
if bc === nothing
bc = ones(Int64, nsites_bop) # Default: periodic boundary condition
end
# First check transformations with -1 and -1; e.g., (a, b) = (-1, -1)
# These transformations are not supported in _binaryop_mpo_backend.
# To support this case, we need to flip the sign of coeffs as follows:
# f(x, y) = h(x + y, c * x + d * y) = g(-x-y, c * x + d * y),
# where h(x, y) = g(-x, y).
# The transformation is taken place in this order: g -> h -> f.
sign_flips = [coeffs[n][1] == -1 && coeffs[n][2] == -1 for n in 1:length(coeffs)]
coeffs_ = [(sign_flips[i] ? abs.(coeffs[i]) : coeffs[i]) for i in eachindex(coeffs)]
# For g->h
M = _binaryop_mpo_backend(sites, coeffs_, pos_sites_in; rev_carrydirec=rev_carrydirec,
bc=bc)
# For h->f
for i in 1:nsites_bop
if !sign_flips[i]
continue
end
M_ = bc[i] *
flipop(sites[i:nsites_bop:end]; rev_carrydirec=rev_carrydirec, bc=bc[i])
M = apply(M, matchsiteinds(M_, sites); cutoff=1e-25)
end
return M
end
# Limitation: a = -1 and b = -1 not supported. The same applies to (c, d).
function _binaryop_mpo_backend(sites::Vector{Index{T}},
coeffs::Vector{Tuple{Int,Int}},
pos_sites_in::Vector{Tuple{Int,Int}};
rev_carrydirec=false,
bc::Union{Nothing,Vector{Int}}=nothing) where {T<:Number}
nsites = length(sites)
nsites_bop = length(coeffs)
ncsites = nsites ÷ nsites_bop
length(pos_sites_in) == nsites_bop ||
error("Length mismatch between coeffs and pos_sites_in")
if bc === nothing
bc = ones(Int64, nsites_bop) # Default: periodic boundary condition
end
links = [Index(3^nsites_bop, "link=$n") for n in 0:ncsites]
links[1] = Index(1, "link=0")
links[end] = Index(1, "link=$ncsites")
tensors = ITensor[]
sites2d = reshape(sites, nsites_bop, ncsites)
for n in 1:ncsites
sites_ = sites2d[:, n]
cin_on = rev_carrydirec ? (n != ncsites) : (n != 1)
cout_on = rev_carrydirec ? (n != 1) : (n != ncsites)
tensor = binaryop_tensor_multisite(sites_,
coeffs,
pos_sites_in,
cin_on,
cout_on,
bc)
lleft, lright = links[n], links[n + 1]
if rev_carrydirec
replaceind!(tensor, firstind(tensor, "linkout") => lleft)
replaceind!(tensor, firstind(tensor, "linkin") => lright)
else
replaceind!(tensor, firstind(tensor, "linkin") => lleft)
replaceind!(tensor, firstind(tensor, "linkout") => lright)
end
inds_list = [[lleft, sites_[1]', sites_[1]]]
for m in 2:(nsites_bop - 1)
push!(inds_list, [sites_[m]', sites_[m]])
end
push!(inds_list, [lright, sites_[nsites_bop]', sites_[nsites_bop]])
tensors = vcat(tensors, split_tensor(tensor, inds_list))
end
_removeedges!(tensors, sites)
M = truncate(MPO(tensors); cutoff=1e-25)
cleanup_linkinds!(M)
return M
end
"""
For given function `g(x)` and shift `s`, construct an MPO representing `f(x) = g(x + s)`.
x: 0, ..., 2^R - 1
0 <= s <= 2^R - 1
We assume that left site indices correspond to significant digits
"""
function _shift_mpo(sites::Vector{Index{T}}, shift::Int; bc::Int=1) where {T<:Number}
R = length(sites)
0 <= shift <= 2^R - 1 || error("Invalid shift")
ys = Quantics.tobin(shift, R)
links = Index{T}[]
tensors = ITensor[]
for n in 1:R
cin_on = n != R
cout_on = n != 1
sitey = Index(2, "Qubit, y")
t, link_in, link_out = Quantics._binaryop_tensor(1, 1, sites[n]', sitey, sites[n],
cin_on, cout_on, bc)
t *= onehot(sitey => ys[n] + 1)
if n < R
push!(links, Index(dim(link_in), "link=$n"))
replaceind!(t, link_in => links[end])
end
if n > 1
replaceind!(t, link_out => links[n - 1])
end
if n == 1
t *= onehot(link_out => 1)
elseif n == R
t *= onehot(link_in => 1)
end
push!(tensors, t)
end
MPO(tensors)
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 7162 | @doc raw"""
Create a MPO for Fourier transform
We define two integers using the binary format: ``x = (x_1 x_2 ...., x_N)_2``, ``y = (y_1 y_2 ...., y_N)_2``,
where the right most digits are the least significant digits.
Our definition of the Fourier transform is
```math
Y(y) = \frac{1}{\sqrt{N}} \sum_{x=0}^{N-1} X(x) e^{s i \frac{2\pi y x}{N}} = \sum_{x=0}^{N-1} T(y, x) X(x),
```
where we define the transformation matrix ``T`` and ``s = \pm 1``.
The created MPO can transform an input MPS as follows.
We denote the input and output MPS's by ``X`` and ``Y``, respectively.
* ``X(x_1, ..., x_N) = X_1(x_1) ... X_N (x_N)``,
* ``Y(y_N, ..., y_1) = Y_1(y_N) ... Y_N (y_1)``.
"""
function _qft(sites; cutoff::Float64=1e-14, sign::Int=1)
if any([!hastags(inds(s), "Qubit") for s in sites])
error("All siteinds for qft must has Qubit tag")
end
M = _qft_wo_norm(sites; cutoff=cutoff, sign=sign)
M *= 2.0^(-0.5 * length(sites))
# Quick hack: In the Markus's note,
# the digits are ordered oppositely from the present convention.
M = MPO([M[n] for n in length(M):-1:1])
_replace_mpo_siteinds!(M, reverse(sites), sites)
return M
end
function _assign!(M::MPO, n::Int, arr; autoreshape=false)
if autoreshape
arr = reshape(arr, map(dim, inds(M[n]))...)
end
M[n] = ITensor(arr, inds(M[n])...)
return nothing
end
"""
For length(sites) == 1
The resultant MPO is NOT renormalized.
"""
function _qft_nsite1_wo_norm(sites; sign::Int=1)
length(sites) == 1 || error("num sites > 1")
_exp(x, k) = exp(sign * im * π * (x - 1) * (k - 1))
arr = zeros(ComplexF64, 2, 2)
for out in 1:2, in in 1:2
arr[out, in] = _exp(out, in)
end
M = Quantics._zero_mpo(sites)
_assign!(M, 1, arr)
return M
end
function _qft_wo_norm(sites; cutoff::Float64=1e-14, sign::Int=1)
N = length(sites)
if N == 1
return _qft_nsite1_wo_norm(sites; sign=sign)
end
M_prev = _qft_wo_norm(sites[2:end]; cutoff=cutoff, sign=sign)
M_top = _qft_toplayer(sites; sign=sign)
M = _contract(M_top, M_prev)
ITensors.truncate!(M; cutoff=cutoff)
return M
end
function _qft_toplayer(sites; sign::Int=1)
N = length(sites)
N > 1 || error("N must be greater than 1")
tensors = []
# site = 1
arr = zeros(ComplexF64, 2, 2, 2)
for x in 1:2, k in 1:2
# arr: (out, in, link)
arr[x, k, k] = exp(sign * im * π * (x - 1) * (k - 1))
end
push!(tensors, arr)
for n in 2:N
ϕ = π * 0.5^(n - 1)
_exp(x, k) = exp(sign * im * ϕ * (x - 1) * (k - 1))
# Right most tensor
if n == N
# arr: (link, out, in)
arr = zeros(ComplexF64, 2, 2, 2)
for x in 1:2, k in 1:2
arr[k, x, x] = _exp(x, k)
end
push!(tensors, arr)
else
# arr: (link_left, out, in, link_right)
arr = zeros(ComplexF64, 2, 2, 2, 2)
for x in 1:2, k in 1:2
arr[k, x, x, k] = _exp(x, k)
end
push!(tensors, arr)
end
end
M = Quantics._zero_mpo(sites; linkdims=fill(2, N - 1))
for n in 1:N
_assign!(M, n, tensors[n])
end
return M
end
function _contract(M_top, M_prev)
length(M_top) == length(M_prev) + 1 || error("Length mismatch")
N = length(M_top)
M_top = ITensors.replaceprime(M_top, 1 => 2; tags="Qubit")
M_top = ITensors.replaceprime(M_top, 0 => 1; tags="Qubit")
M_top_ = ITensors.data(M_top)
M_prev_ = ITensors.data(M_prev)
M_data = [M_top_[1]]
for n in 1:(N - 1)
push!(M_data, M_top_[n + 1] * M_prev_[n])
end
M = MPO(M_data)
M = ITensors.replaceprime(M, 1 => 0; tags="Qubit")
M = ITensors.replaceprime(M, 2 => 1; tags="Qubit")
return M
end
abstract type AbstractFT end
struct FTCore
forward::MPO
function FTCore(sites; kwargs...)
new(_qft(sites; kwargs...))
end
end
nbit(ft::AbstractFT) = length(ft.ftcore.forward)
@doc raw"""
sites[1] corresponds to the most significant digit.
sign = 1
```math
Y(y) = \frac{1}{\sqrt{N}} \sum_{x=0}^{N-1} X(x) e^{s i \frac{2\pi (y + y0) (x + x0)}{N}},
```
"""
function forwardmpo(ftcore::FTCore, sites)
M = copy(ftcore.forward)
_replace_mpo_siteinds!(M, _extractsites(M), sites)
return M
end
function backwardmpo(ftcore::FTCore, sites)
M = conj(MPO(reverse([x for x in ftcore.forward])))
_replace_mpo_siteinds!(M, _extractsites(M), sites)
return M
end
function _apply_qft(M::MPO, gsrc::MPS, target_sites, sitepos, sitesdst; kwargs...)
_replace_mpo_siteinds!(M, _extractsites(M), target_sites)
M = matchsiteinds(M, siteinds(gsrc))
gdst = ITensors.apply(M, gsrc; kwargs...)
N = length(target_sites)
for n in eachindex(target_sites)
replaceind!(gdst[sitepos[n]], target_sites[n], sitesdst[N - n + 1])
end
return gdst
end
@doc raw"""
Perform Fourier transform for a subset of qubit indices.
We define two integers using the binary format: ``x = (x_1 x_2 ...., x_R)_2``, ``y = (y_1 y_2 ...., y_R)_2``,
where the right most digits are the least significant digits.
The variable `x` is denoted as `src` (source), and the variable `y` is denoted as `dst` (destination).
Our definition of the Fourier transform is
```math
Y(y) = \frac{1}{\sqrt{N}} \sum_{x=0}^{N-1} X(x) e^{s i \frac{2\pi (y + y_0) (x + x_0)}{N}}
```
where ``s = \pm 1``, ``x_0`` and ``y_0`` are constants, ``N=2^R``.
`sitessrc[1]` / `sitessrc[end]` corresponds to the most/least significant digit of the input.
`sitesdst[1]` / `sitesdst[end]` corresponds to the most/least significant digit of the output.
`siteinds(M)` must contain `sitessrc` in ascending or descending order.
Instead of specifying `sitessrc`, one can specify the source sites by setting `tag`.
If `tag` = `x`, all sites with tags `x=1`, `x=2`, ... are used as `sitessrc`.
"""
function fouriertransform(M::MPS;
sign::Int=1,
tag::String="",
sitessrc=nothing,
sitesdst=nothing,
originsrc::Float64=0.0,
origindst::Float64=0.0,
cutoff_MPO=1e-25, kwargs...)
sites = siteinds(M)
sitepos, target_sites = _find_target_sites(M; sitessrc=sitessrc, tag=tag)
if sitesdst === nothing
sitesdst = target_sites
end
if length(target_sites) <= 1
error("Invalid target_sites")
end
# Prepare MPO for QFT
MQ_ = _qft(target_sites; sign=sign, cutoff=cutoff_MPO)
MQ = matchsiteinds(MQ_, sites)
# Phase shift from origindst
M_result = phase_rotation(M, sign * 2π * origindst / (2.0^length(sitepos));
targetsites=target_sites)
# Apply QFT
M_result = apply(MQ, M_result; kwargs...)
N = length(target_sites)
for n in eachindex(target_sites)
replaceind!(M_result[sitepos[n]], target_sites[n], sitesdst[N - n + 1])
end
# Phase shift from originsrc
M_result = phase_rotation(M_result, sign * 2π * originsrc / (2.0^length(sitepos));
targetsites=sitesdst)
M_result *= exp(sign * im * 2π * originsrc * origindst / 2.0^length(sitepos))
return M_result
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 3147 |
@doc """
For imaginary-time/-frequency domains
"""
struct ImaginaryTimeFT <: AbstractFT
ftcore::FTCore
function ImaginaryTimeFT(ftcore::FTCore)
new(ftcore)
end
end
_stat_shift(::Fermionic) = 1
_stat_shift(::Bosonic) = 0
_stat_sign(::Fermionic) = -1
_stat_sign(::Bosonic) = 1
function to_wn(stat::Statistics, gtau::MPS, beta::Float64; sitessrc=nothing, tag="",
sitesdst=nothing, kwargs...)::MPS
sitepos, _ = _find_target_sites(gtau; sitessrc=sitessrc, tag=tag)
nqbit_t = length(sitepos)
originwn = 0.5 * (-2.0^nqbit_t + _stat_shift(stat))
giv = fouriertransform(gtau; tag=tag, sitessrc=sitessrc, sitesdst=sitesdst,
origindst=originwn, kwargs...)
giv *= (beta * 2^(-nqbit_t / 2))
return giv
end
function to_tau(stat::Statistics, giv::MPS, beta::Float64; sitessrc=nothing, tag="",
sitesdst=nothing, kwargs...)::MPS
sitepos, _ = _find_target_sites(giv; sitessrc=sitessrc, tag=tag)
nqbit_t = length(sitepos)
originwn = 0.5 * (-2.0^nqbit_t + _stat_shift(stat))
gtau = fouriertransform(giv; sign=-1, tag=tag, sitessrc=sitessrc, sitesdst=sitesdst,
originsrc=originwn, kwargs...)
gtau *= ((2^(nqbit_t / 2)) / beta)
return gtau
end
function decompose_gtau(gtau_smpl::Vector{ComplexF64}, sites; kwargs...)
nbit = length(sites)
length(gtau_smpl) == 2^nbit || error("Length mismatch")
# (g_1, g_2, ...)
gtau_smpl = reshape(gtau_smpl, repeat([2], nbit)...)
gtau_smpl = permutedims(gtau_smpl, reverse(collect(1:nbit)))
return MPS(gtau_smpl, sites; kwargs...)
end
"""
w = (w_1 w_2, ..., w_R)_2
In the resultant MPS, the site indices are
w_R, w_{R-1}, ..., w_1 from the left to the right.
sites: indices for w_1, ..., w_R in this order.
"""
function decompose_giv(giv_smpl::Vector{ComplexF64}, sites; kwargs...)
nbit = length(sites)
length(giv_smpl) == 2^nbit || error("Length mismatch")
tensor = ITensor(giv_smpl, reverse(sites))
return MPS(tensor, reverse(sites); kwargs...)
end
"""
Construct an MPS representing G(τ) generated by a pole
"""
function poletomps(stat::Statistics, sites, β, ω)
nqubits = length(sites)
links = [Index(1, "Link,l=$l") for l in 0:nqubits]
tensors = ITensor[]
for n in 1:nqubits
push!(tensors,
ITensor([1.0, exp(-(0.5^n) * β * ω)], links[n], links[n + 1], sites[n]))
end
tensors[1] *= -1 / (1 - _stat_sign(stat) * exp(-β * ω))
tensors[1] *= onehot(links[1] => 1)
tensors[end] *= onehot(links[end] => 1)
return MPS(tensors)
end
"""
Construct an MPS representing fermionic G(τ) generated by a pole
"""
function poletomps(::Fermionic, sites, β, ω)
if β * ω < -100.0
R = length(sites)
sites_ = [Index(2, "Qubit,τ=$n") for n in 1:R]
tmp = reverseaxis(Quantics.expqtt(sites_, β * ω); tag="τ", bc=1)
res = shiftaxis(tmp, +1; tag="τ", bc=1) * (-exp(β * ω / 2^R))
for n in 1:R
replaceind!(res[n], sites_[n] => sites[n])
end
return res
end
return expqtt(sites, -β * ω) / (-1 - exp(-β * ω))
end
poletomps(sites, β, ω) = poletomps(Fermionic(), sites, β, ω)
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 922 | """
Create a MPS filled with one
"""
function onemps(::Type{T}, sites) where {T<:Number}
M = MPS(T, sites; linkdims=1)
l = linkinds(M)
for n in eachindex(M)
if n == 1
M[n] = ITensor(T, sites[n], l[n])
elseif n == length(M)
M[n] = ITensor(T, l[n - 1], sites[n])
else
M[n] = ITensor(T, l[n - 1], sites[n], l[n])
end
M[n] .= one(T)
end
return M
end
"""
Create an MPS representing exp(a*x) on [0, 1) in QTT
exp(-a*x) = prod_{n=1}^R exp(a * 2^(-n) * x_n)
"""
function expqtt(sites, a::Float64)
R = length(sites)
links = [Index(1, "Link,l=$l") for l in 0:R]
tensors = ITensor[]
for n in 1:R
push!(tensors,
ITensor([1.0, exp(a * (0.5^n))], links[n], links[n + 1], sites[n]))
end
tensors[1] *= onehot(links[1] => 1)
tensors[end] *= onehot(links[end] => 1)
return MPS(tensors)
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 5147 | abstract type AbstractMultiplier end
#===
Matrix multiplication
===#
struct MatrixMultiplier{T} <: AbstractMultiplier where {T}
sites_row::Vector{Index{T}}
sites_shared::Vector{Index{T}}
sites_col::Vector{Index{T}}
function MatrixMultiplier(sites_row::Vector{Index{T}},
sites_shared::Vector{Index{T}},
sites_col::Vector{Index{T}}) where {T}
new{T}(sites_row, sites_shared, sites_col)
end
end
function MatrixMultiplier(site_row::Index{T},
site_shared::Index{T},
site_col::Index{T}) where {T}
return MatrixMultiplier([site_row], [site_shared], [site_col])
end
function preprocess(mul::MatrixMultiplier{T}, M1::MPO, M2::MPO) where {T}
for (site_row, site_shared, site_col) in zip(mul.sites_row, mul.sites_shared,
mul.sites_col)
M1, M2 = combinesites(M1, site_row, site_shared),
combinesites(M2, site_col, site_shared)
end
return M1, M2
end
function postprocess(mul::MatrixMultiplier{T}, M::MPO)::MPO where {T}
tensors = ITensors.data(M)
for (site_row, site_col) in zip(mul.sites_row, mul.sites_col)
p = findfirst(hasind(site_row), tensors)
hasind(tensors[p], site_col) ||
error("$site_row and $site_col are not on the same site")
indsl = [site_row]
if p > 1
push!(indsl, linkind(M, p - 1))
end
indsr = [site_col]
if p < length(M)
push!(indsr, linkind(M, p))
end
Ml, Mr = split_tensor(tensors[p], [indsl, indsr])
deleteat!(tensors, p)
insert!(tensors, p, Ml)
insert!(tensors, p + 1, Mr)
end
return MPO(tensors)
end
#===
Elementwise multiplication
===#
struct ElementwiseMultiplier{T} <: AbstractMultiplier where {T}
sites::Vector{Index{T}}
function ElementwiseMultiplier(sites::Vector{Index{T}}) where {T}
new{T}(sites)
end
end
"""
Convert an MPS tensor to an MPO tensor with a diagonal structure
"""
function _asdiagonal(t, site::Index{T})::ITensor where {T<:Number}
hasinds(t, site') && error("Found $(site')")
links = uniqueinds(inds(t), site)
rawdata = Array(t, links..., site)
tensor = zeros(eltype(t), size(rawdata)..., dim(site))
for i in 1:dim(site)
tensor[.., i, i] = rawdata[.., i]
end
return ITensor(tensor, links..., site', site)
end
function _todense(t, site::Index{T}) where {T<:Number}
links = uniqueinds(inds(t), site, site'')
newdata = zeros(eltype(t), dim.(links)..., dim(site))
if length(links) == 2
olddata = Array(t, links..., site, site'')
for i in 1:dim(site)
newdata[:, :, i] = olddata[:, :, i, i]
end
elseif length(links) == 1
olddata = Array(t, links..., site, site'')
for i in 1:dim(site)
newdata[:, i] = olddata[:, i, i]
end
else
error("Too many links found: $links")
end
return ITensor(newdata, links..., site)
end
function preprocess(mul::ElementwiseMultiplier{T}, M1::MPO, M2::MPO) where {T}
tensors1 = ITensors.data(M1)
tensors2 = ITensors.data(M2)
for s in mul.sites
p = findfirst(hasind(s), tensors1)
hasinds(tensors2[p], s) || error("ITensor of M2 at $p does not have $s")
#tensors1[p] = replaceprime(_asdiagonal(tensors1[p], s), 0 => 1, 1 => 2)
tensors1[p] = _asdiagonal(tensors1[p], s)
replaceind!(tensors1[p], s' => s'')
replaceind!(tensors1[p], s => s')
tensors2[p] = _asdiagonal(tensors2[p], s)
end
return MPO(tensors1), MPO(tensors2)
end
function postprocess(mul::ElementwiseMultiplier{T}, M::MPO)::MPO where {T}
tensors = ITensors.data(M)
for s in mul.sites
p = findfirst(hasind(s), tensors)
tensors[p] = _todense(tensors[p], s)
end
return MPO(tensors)
end
"""
By default, elementwise multiplication will be performed.
"""
function automul(M1::MPS, M2::MPS; tag_row::String="", tag_shared::String="",
tag_col::String="", alg="naive", kwargs...)
if in(:maxbonddim, keys(kwargs))
error("Illegal keyward parameter: maxbonddim. Use maxdim instead!")
end
sites_row = findallsiteinds_by_tag(siteinds(M1); tag=tag_row)
sites_shared = findallsiteinds_by_tag(siteinds(M1); tag=tag_shared)
sites_col = findallsiteinds_by_tag(siteinds(M2); tag=tag_col)
sites_matmul = Set(Iterators.flatten([sites_row, sites_shared, sites_col]))
if sites_shared != findallsiteinds_by_tag(siteinds(M2); tag=tag_shared)
error("Invalid shared sites for MatrixMultiplier")
end
matmul = MatrixMultiplier(sites_row, sites_shared, sites_col)
ewmul = ElementwiseMultiplier([s for s in siteinds(M1) if s ∉ sites_matmul])
M1_ = Quantics.asMPO(M1)
M2_ = Quantics.asMPO(M2)
M1_, M2_ = preprocess(matmul, M1_, M2_)
M1_, M2_ = preprocess(ewmul, M1_, M2_)
M = FastMPOContractions.contract_mpo_mpo(M1_, M2_; alg=alg, kwargs...)
M = Quantics.postprocess(matmul, M)
M = Quantics.postprocess(ewmul, M)
if in(:maxdim, keys(kwargs))
truncate!(M; maxdim=kwargs[:maxdim])
end
return asMPS(M)
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 2047 |
# A valid tag should not contain "=".
_valid_tag(tag::String)::Bool = !occursin("=", tag)
"""
Find sites with the given tag
For tag = `x`, if `sites` contains an Index object with `x`, the function returns a vector containing only its positon.
If not, the function seach for all Index objects with tags `x=1`, `x=2`, ..., and return their positions.
If no Index object is found, an empty vector will be returned.
"""
function findallsites_by_tag(sites::Vector{Index{T}}; tag::String="x",
maxnsites::Int=1000)::Vector{Int} where {T}
_valid_tag(tag) || error("Invalid tag: $tag")
result = Int[]
for n in 1:maxnsites
tag_ = tag * "=$n"
idx = findall(hastags(tag_), sites)
if length(idx) == 0
break
elseif length(idx) > 1
error("Found more than one site indices with $(tag_)!")
end
push!(result, idx[1])
end
return result
end
function findallsiteinds_by_tag(
sites::AbstractVector{Index{T}}; tag::String="x", maxnsites::Int=1000) where {T}
_valid_tag(tag) || error("Invalid tag: $tag")
positions = findallsites_by_tag(sites; tag=tag, maxnsites=maxnsites)
return [sites[p] for p in positions]
end
function findallsites_by_tag(sites::Vector{Vector{Index{T}}}; tag::String="x",
maxnsites::Int=1000)::Vector{NTuple{2,Int}} where {T}
_valid_tag(tag) || error("Invalid tag: $tag")
sites_dict = Dict{Index{T},NTuple{2,Int}}()
for i in 1:length(sites)
for j in 1:length(sites[i])
sites_dict[sites[i][j]] = (i, j)
end
end
result = NTuple{2,Int}[]
sitesflatten = collect(Iterators.flatten(sites))
for n in 1:maxnsites
tag_ = tag * "=$n"
idx = findall(i -> hastags(i, tag_) && hasplev(i, 0), sitesflatten)
if length(idx) == 0
break
elseif length(idx) > 1
error("Found more than one site indices with $(tag_)!")
end
push!(result, sites_dict[sitesflatten[only(idx)]])
end
return result
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 7909 | function _single_tensor_flip()
cval = [-1, 0]
# (cin, cout, s', s)
single_tensor = zeros(Float64, 2, 2, 2, 2)
for icin in 1:2
for a in 1:2
out = -(a - 1) + cval[icin]
icout = out < 0 ? 1 : 2
b = mod(out, 2) + 1
single_tensor[icin, icout, a, b] = 1
end
end
return single_tensor
end
"""
This function returns an MPO, M, representing the transformation
f(x) = g(-x)
where f(x) = M * g(x) for x = 0, 1, ..., 2^R-1.
"""
function flipop_to_negativedomain(sites::Vector{Index{T}}; rev_carrydirec=false,
bc::Int=1)::MPO where {T}
return flipop(sites; rev_carrydirec=rev_carrydirec, bc=bc) * bc
end
"""
This function returns an MPO, M, representing the transformation
f(x) = g(2^R-x)
where f(x) = M * g(x) for x = 0, 1, ..., 2^R-1.
`sites`: the sites of the output MPS
"""
function flipop(sites::Vector{Index{T}}; rev_carrydirec=false, bc::Int=1)::MPO where {T}
if rev_carrydirec
M = flipop(reverse(sites); rev_carrydirec=false, bc=bc)
return MPO([M[n] for n in reverse(1:length(M))])
end
N = length(sites)
abs(bc) == 1 || error("bc must be either 1, -1")
N > 1 || error("MPO with one tensor is not supported")
t = _single_tensor_flip()
M = MPO(N)
links = [Index(2, "Link,l=$l") for l in 1:(N + 1)]
for n in 1:N
M[n] = ITensor(t, (links[n], links[n + 1], sites[n]', sites[n]))
end
M[1] *= onehot(links[1] => 2)
bc_tensor = ITensor([1.0, bc], links[end])
M[N] = M[N] * bc_tensor
cleanup_linkinds!(M)
return M
end
@doc """
f(x) = g(N - x) = M * g(x) for x = 0, 1, ..., N-1,
where x = 0, 1, ..., N-1 and N = 2^R.
Note that x = 0, 1, 2, ..., N-1 are mapped to x = 0, N-1, N-2, ..., 1 mod N.
"""
function reverseaxis(M::MPS; tag="x", bc::Int=1, kwargs...)
bc ∈ [1, -1] || error("bc must be either 1 or -1")
return apply(reverseaxismpo(siteinds(M); tag=tag, bc=bc), M; kwargs...)
end
function reverseaxismpo(sites::AbstractVector{Index{T}}; tag="x", bc::Int=1)::MPO where {T}
bc ∈ [1, -1] || error("bc must be either 1 or -1")
targetsites = findallsiteinds_by_tag(sites; tag=tag)
pos = findallsites_by_tag(sites; tag=tag)
!isascendingordescending(pos) && error("siteinds for tag $(tag) must be sorted.")
rev_carrydirec = isascendingorder(pos)
siteinds_MPO = rev_carrydirec ? targetsites : reverse(targetsites)
transformer_tag = flipop(siteinds_MPO; rev_carrydirec=rev_carrydirec, bc=bc)
return matchsiteinds(transformer_tag, sites)
end
"""
f(x) = g(x + shift) for x = 0, 1, ..., 2^R-1 and 0 <= shift < 2^R.
"""
function shiftaxis(M::MPS, shift::Int; tag="x", bc::Int=1, kwargs...)
bc ∈ [1, -1] || error("bc must be either 1 or -1")
return apply(shiftaxismpo(siteinds(M), shift; tag=tag, bc=bc), M; kwargs...)
end
"""
f(x) = g(x + shift) for x = 0, 1, ..., 2^R-1 and 0 <= shift < 2^R.
"""
function shiftaxismpo(sites::AbstractVector{Index{T}}, shift::Int; tag="x", bc::Int=1)::MPO where {T}
bc ∈ [1, -1] || error("bc must be either 1 or -1")
targetsites = findallsiteinds_by_tag(sites; tag=tag) # From left to right: x=1, 2, ...
pos = findallsites_by_tag(sites; tag=tag)
!isascendingordescending(pos) && error("siteinds for tag $(tag) must be sorted.")
rev_carrydirec = isascendingorder(pos)
R = length(targetsites)
nbc, shift_mod = divrem(shift, 2^R, RoundDown)
if rev_carrydirec
transformer = _shift_mpo(targetsites, shift_mod; bc=bc)
else
transformer = _shift_mpo(targetsites, shift_mod; bc=bc)
transformer = MPO([transformer[n] for n in reverse(1:length(transformer))])
end
transformer = matchsiteinds(transformer, sites)
transformer *= bc^nbc
return transformer
end
"""
Multiply by exp(i θ x), where x = (x_1, ..., x_R)_2.
"""
function phase_rotation(M::MPS, θ::Float64; targetsites=nothing, tag="")::MPS
transformer = phase_rotation_mpo(siteinds(M), θ; targetsites=targetsites, tag=tag)
apply(transformer, M)
end
"""
Create an MPO for multiplication by `exp(i θ x)`, where `x = (x_1, ..., x_R)_2`.
`sites`: site indices for `x_1`, `x_2`, ..., `x_R`.
"""
function phase_rotation_mpo(sites::AbstractVector{Index{T}}, θ::Float64; targetsites=nothing, tag="")::MPO where {T}
_, target_sites = _find_target_sites(sites; sitessrc=targetsites, tag=tag)
transformer = _phase_rotation_mpo(target_sites, θ)
return matchsiteinds(transformer, sites)
end
function _phase_rotation_mpo(sites::AbstractVector{Index{T}}, θ::Float64)::MPO where {T}
R = length(sites)
tensors = [ITensor(true) for _ in 1:R]
for n in 1:R
tensors[n] = op("Phase", sites[n]; ϕ=θ * 2^(R - n))
end
links = [Index(1, "Link,l=$l") for l in 1:(R-1)]
tensors[1] = ITensor(Array(tensors[1], sites[1]', sites[1]), sites[1], sites[1]', links[1])
for l in 2:(R-1)
tensors[l] = ITensor(Array(tensors[l], sites[l]', sites[l]), links[l-1], sites[l], sites[l]', links[l])
end
tensors[end] = ITensor(Array(tensors[end], sites[end]', sites[end]), links[end], sites[end], sites[end]')
return MPO(tensors)
end
function _upper_lower_triangle(upper_or_lower::Symbol)::Array{Float64,4}
upper_or_lower ∈ [:upper, :lower] || error("Invalid upper_or_lower $(upper_or_lower)")
T = Float64
t = zeros(T, 2, 2, 2, 2) # left link, right link, site', site
t[1, 1, 1, 1] = one(T)
t[1, 1, 2, 2] = one(T)
if upper_or_lower == :upper
t[1, 2, 1, 2] = one(T)
t[1, 2, 2, 1] = zero(T)
else
t[1, 2, 1, 2] = zero(T)
t[1, 2, 2, 1] = one(T)
end
# If a comparison is made at a higher bit, we respect it.
t[2, 2, :, :] .= one(T)
return t
end
"""
Create QTT for a upper/lower triangle matrix filled with one except the diagonal line
"""
function upper_lower_triangle_matrix(sites::Vector{Index{T}}, value::S;
upper_or_lower::Symbol=:upper)::MPO where {T,S}
upper_or_lower ∈ [:upper, :lower] || error("Invalid upper_or_lower $(upper_or_lower)")
N = length(sites)
t = _upper_lower_triangle(upper_or_lower)
M = MPO(N)
links = [Index(2, "Link,l=$l") for l in 1:(N + 1)]
for n in 1:N
M[n] = ITensor(t, (links[n], links[n + 1], sites[n]', sites[n]))
end
M[1] *= onehot(links[1] => 1)
M[N] *= ITensor(S[0, value], links[N + 1])
return M
end
"""
Create MPO for cumulative sum in QTT
includeown = False
y_i = sum_{j=1}^{i-1} x_j
"""
function cumsum(sites::Vector{Index}; includeown::Bool=false)
includeown == False || error("includeown = True has not been implmented yet")
return upper_triangle_matrix(sites, 1.0)
end
"""
Add new site indices to an MPS
"""
#==
function asdiagonal(M::MPS, newsites; which_new="right", targetsites=nothing, tag="")
which_new ∈ ["left", "right"] || error("Invalid which_new: left or right")
sitepos, target_sites = Quantics._find_target_sites(M; sitessrc=targetsites, tag=tag)
length(sitepos) == length(newsites) ||
error("Length mismatch: $(newsites) vs $(target_sites)")
M_ = Quantics._addedges(M)
links = linkinds(M_)
tensors = ITensor[]
for p in 1:length(M)
if !(p ∈ sitepos)
push!(tensors, copy(M_[p]))
continue
end
i = findfirst(x -> x == p, sitepos)
s = target_sites[i]
s1 = sim(s)
ll, lr = links[p], links[p + 1]
t = replaceind(M_[p], s => s1)
if which_new == "right"
tl, tr = factorize(delta(s1, s, newsites[i]) * t, ll, s)
else
tl, tr = factorize(delta(s1, s, newsites[i]) * t, ll, newsites[i])
end
push!(tensors, tl)
push!(tensors, tr)
end
tensors[1] *= onehot(links[1] => 1)
tensors[end] *= onehot(links[end] => 1)
M_result = MPS(tensors)
Quantics.cleanup_linkinds!(M_result)
return M_result
end
==#
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 16006 | function _extractsite(x::Union{MPS,MPO}, n::Int)
if n == 1
return noprime(copy(uniqueind(x[n], x[n + 1])))
elseif n == length(x)
return noprime(copy(uniqueind(x[n], x[n - 1])))
else
return noprime(copy(uniqueind(x[n], x[n + 1], x[n - 1])))
end
end
_extractsites(x::Union{MPS,MPO}) = [_extractsite(x, n) for n in eachindex(x)]
function _replace_mpo_siteinds!(M::MPO, sites_src, sites_dst)
sites_src = noprime(sites_src)
sites_dst = noprime(sites_dst)
for j in eachindex(M)
replaceind!(M[j], sites_src[j], sites_dst[j])
replaceind!(M[j], sites_src[j]', sites_dst[j]')
end
return M
end
"""
Reverse the order of the MPS/MPO tensors
The order of the siteinds are reversed in the returned object.
"""
function _reverse(M::MPO)
sites = _extractsites(M)
N = length(M)
M_ = MPO([M[n] for n in reverse(1:length(M))])
for n in 1:N
replaceind!(M_[n], sites[N - n + 1], sites[n])
replaceind!(M_[n], sites[N - n + 1]', sites[n]')
end
return M_
end
"""
Create a MPO with ITensor objects of ElType ComplexF64 filled with zero
"""
function _zero_mpo(sites; linkdims=ones(Int, length(sites) - 1))
length(linkdims) == length(sites) - 1 ||
error("Length mismatch $(length(linkdims)) != $(length(sites)) - 1")
M = MPO(sites)
N = length(M)
links = [Index(1, "n=0,Link")]
for n in 1:(N - 1)
push!(links, Index(linkdims[n], "n=$(n),Link"))
end
push!(links, Index(1, "n=$N,Link"))
for n in 1:N
inds_ = (links[n], sites[n]', sites[n], links[n + 1])
elm_ = zeros(ComplexF64, map(ITensors.dim, inds_)...)
M[n] = ITensor(elm_, inds_...)
end
M[1] *= ITensors.delta(links[1])
M[N] *= ITensors.delta(links[N + 1])
return M
end
# Compute linkdims for a maximally entangled state
function maxlinkdims(inds)
N = length(inds)
for i in 1:N
@assert !ITensors.hastags(inds, "Link")
end
physdims = dim.(inds)
maxdim = ones(Float64, N - 1)
maxdiml = 1.0
for i in 1:(N - 1)
maxdiml *= physdims[i]
maxdim[i] = maxdiml
end
maxdimr = 1.0
for i in 1:(N - 1)
maxdimr *= physdims[N + 1 - i]
maxdim[N - i] = min(maxdimr, maxdim[N - i])
end
return maxdim
end
"""
Un-fuse the site indices of an MPS at the given sites
M: Input MPS where each tensor has only one site index
target_sites: Vector of siteinds to be split
new_sites: Vector of vectors of new siteinds
When splitting MPS tensors, the column major is assumed.
"""
function unfuse_siteinds(M::MPS, targetsites::Vector{Index{T}},
newsites::AbstractVector{Vector{Index{T}}})::MPS where {T}
length(targetsites) == length(newsites) || error("Length mismatch")
links = linkinds(M)
L = length(M)
tensors = Union{ITensor,Vector{ITensor}}[deepcopy(M[n]) for n in eachindex(M)]
for n in 1:length(targetsites)
pos = findsite(M, targetsites[n])
!isnothing(pos) || error("Target site not found: $(targetsites[n])")
newinds = [[s] for s in newsites[n]]
links_ = Index{T}[]
if pos > 1
push!(links_, links[pos - 1])
push!(newinds[1], links[pos - 1])
end
if pos < L
push!(links_, links[pos])
push!(newinds[end], links[pos])
end
tensor_data = ITensors.data(permute(copy(M[pos]), targetsites[n], links_...))
tensors[pos] = split_tensor(ITensor(tensor_data, newsites[n]..., links_...),
newinds)
end
tensors_ = ITensor[]
for t in tensors
if t isa ITensor
push!(tensors_, t)
elseif t isa Vector{ITensor}
for t_ in t
push!(tensors_, t_)
end
end
end
M_ = MPS(tensors_)
cleanup_linkinds!(M_)
return M_
end
function _removeedges!(x::MPS, sites)
length(inds(x[1])) == 3 || error("Dim of the first tensor must be 3")
length(inds(x[end])) == 3 || error("Dim of the last tensor must be 3")
elt = eltype(x[1])
x[1] *= onehot(elt, uniqueind(x[1], x[2], sites) => 1)
x[end] *= onehot(elt, uniqueind(x[end], x[end - 1], sites) => 1)
return nothing
end
function _removeedges!(x::MPO, sites)
length(inds(x[1])) == 4 || error("Dim of the first tensor must be 4")
length(inds(x[end])) == 4 || error("Dim of the last tensor must be 4")
elt = eltype(x[1])
x[1] *= onehot(elt, uniqueind(x[1], x[2], sites, prime.(sites)) => 1)
x[end] *= onehot(elt, uniqueind(x[end], x[end - 1], sites, prime.(sites)) => 1)
return nothing
end
function _removeedges!(tensors::Vector{ITensor}, sites)
tensors[1] *= onehot(Float64,
uniqueind(tensors[1], tensors[2], sites, prime.(sites)) => 1)
tensors[end] *= onehot(Float64,
uniqueind(tensors[end], tensors[end - 1], sites, prime.(sites)) => 1)
end
function _addedges!(x::MPS)
length(inds(x[1])) == 2 || error("Dim of the first tensor must be 2")
length(inds(x[end])) == 2 || error("Dim of the last tensor must be 2")
linkl = Index(1, "Link,l=0")
linkr = Index(1, "Link,l=$(length(x))")
x[1] = ITensor(ITensors.data(x[1]), [linkl, inds(x[1])...])
x[end] = ITensor(ITensors.data(x[end]), [inds(x[end])..., linkr])
return nothing
end
function _addedges!(x::MPO)
length(inds(x[1])) == 3 || error("Dim of the first tensor must be 3")
length(inds(x[end])) == 3 || error("Dim of the last tensor must be 3")
linkl = Index(1, "Link,l=0")
linkr = Index(1, "Link,l=$(length(x))")
x[1] = ITensor(ITensors.data(x[1]), [linkl, inds(x[1])...])
x[end] = ITensor(ITensors.data(x[end]), [inds(x[end])..., linkr])
return nothing
end
"""
Decompose the given tensor into as the product of tensors by QR
The externel indices of the results tensors are specified by `inds_list`.
"""
function split_tensor(tensor::ITensor, inds_list::Vector{Vector{Index{T}}}) where {T}
inds_list = deepcopy(inds_list)
result = ITensor[]
for (i, inds) in enumerate(inds_list)
if i == length(inds_list)
push!(result, tensor)
else
Q, R, _ = qr(tensor, inds)
push!(result, Q)
if i < length(inds_list)
push!(inds_list[i + 1], commonind(Q, R))
end
tensor = R
end
end
return result
end
function cleanup_linkinds!(M)
links_new = [Index(dim(l), "Link,l=$idx") for (idx, l) in enumerate(linkinds(M))]
links_old = linkinds(M)
for n in 1:length(M)
if n < length(M)
replaceind!(M[n], links_old[n], links_new[n])
end
if n > 1
replaceind!(M[n], links_old[n - 1], links_new[n - 1])
end
end
M
end
"""
To bits
"""
function tobin!(x::Int, xbin::Vector{Int})
nbit = length(xbin)
mask = 1 << (nbit - 1)
for i in 1:nbit
xbin[i] = (mask & x) >> (nbit - i)
mask = mask >> 1
end
end
function tobin(x::Int, R::Int)
bin = zeros(Int, R)
tobin!(x, bin)
return bin
end
# Get bit at pos (>=0). pos=0 is the least significant digit.
_getbit(i, pos) = ((i & (1 << pos)) >> pos)
isascendingorder(x) = issorted(x; lt=isless)
isdecendingorder(x) = issorted(x; lt=Base.isgreater)
isascendingordescending(x) = isascendingorder(x) || isdecendingorder(x)
function kronecker_deltas(sitesin; sitesout=prime.(noprime.(sitesin)))
N = length(sitesout)
links = [Index(1, "Link,l=$l") for l in 0:N]
M = MPO([delta(links[n], links[n + 1], sitesout[n], sitesin[n]) for n in 1:N])
M[1] *= onehot(links[1] => 1)
M[end] *= onehot(links[end] => 1)
return M
end
"""
Match MPS/MPO to the given site indices
MPS:
The resultant MPS do not depends on the missing site indices.
MPO:
For missing site indices, identity operators are inserted.
"""
function matchsiteinds(M::Union{MPS,MPO}, sites)
N = length(sites)
sites = noprime.(sites)
positions = Int[findfirst(sites, s) for s in siteinds(M)]
if length(M) > 1 && issorted(positions; lt=Base.isgreater)
return matchsiteinds(MPO([M[n] for n in reverse(1:length(M))]), sites)
end
Quantics.isascendingorder(positions) ||
error("siteinds are not in ascending order!")
# Add edges
M_ = deepcopy(M)
linkl = Index(1, "Link,l=0")
linkr = Index(1, "Link,l=$N")
M_[1] = ITensor(ITensors.data(M_[1]), [linkl, inds(M_[1])...])
M_[end] = ITensor(ITensors.data(M_[end]), [inds(M_[end])..., linkr])
linkdims_org = [1, dim.(linkinds(M))..., 1]
linkdims_new = [1, zeros(Int, N - 1)..., 1]
for n in eachindex(positions)
p = positions[n]
linkdims_new[p] = linkdims_org[n]
linkdims_new[p + 1] = linkdims_org[n + 1]
end
# Fill gaps
while any(linkdims_new .== 0)
for n in eachindex(linkdims_new)
if linkdims_new[n] == 0
if n >= 2 && linkdims_new[n - 1] != 0
linkdims_new[n] = linkdims_new[n - 1]
elseif n < length(linkdims_new) && linkdims_new[n + 1] != 0
linkdims_new[n] = linkdims_new[n + 1, 1]
end
end
end
end
links = [Index(linkdims_new[l], "Link,l=$(l-1)") for l in eachindex(linkdims_new)]
if M isa MPO
tensors = [delta(links[n], links[n + 1]) * delta(sites[n], sites[n]')
for n in eachindex(sites)]
elseif M isa MPS
tensors = [delta(links[n], links[n + 1]) * ITensor(1, sites[n])
for n in eachindex(sites)]
end
links_old = [linkl, linkinds(M)..., linkr]
for n in eachindex(positions)
p = positions[n]
tensor = copy(M_[n])
replaceind!(tensor, links_old[n], links[p])
replaceind!(tensor, links_old[n + 1], links[p + 1])
if M isa MPO
tensors[p] = permute(tensor, [links[p], links[p + 1], sites[p], sites[p]'])
elseif M isa MPS
tensors[p] = permute(tensor, [links[p], links[p + 1], sites[p]])
end
end
tensors[1] *= onehot(links[1] => 1)
tensors[end] *= onehot(links[end] => 1)
return typeof(M)(tensors)
end
asMPO(M::MPO) = M
function asMPO(tensors::Vector{ITensor})
N = length(tensors)
M = MPO(N)
for n in 1:N
M[n] = tensors[n]
end
return M
end
function asMPO(M::MPS)
return asMPO(ITensors.data(M))
end
function asMPS(M::MPO)
return MPS([t for t in M])
end
"""
Contract two adjacent tensors in MPO
"""
function combinesites(M::MPO, site1::Index, site2::Index)
p1 = findsite(M, site1)
p2 = findsite(M, site2)
p1 === nothing && error("Not found $site1")
p2 === nothing && error("Not found $site2")
abs(p1 - p2) == 1 ||
error("$site1 and $site2 are found at indices $p1 and $p2. They must be on two adjacent sites.")
tensors = ITensors.data(M)
idx = min(p1, p2)
tensor = tensors[idx] * tensors[idx + 1]
deleteat!(tensors, idx:(idx + 1))
insert!(tensors, idx, tensor)
return MPO(tensors)
end
function directprod(::Type{T}, sites, indices) where {T}
length(sites) == length(indices) || error("Length mismatch between sites and indices")
any(0 .== indices) && error("indices must be 1-based")
R = length(sites)
links = [Index(1, "Link,l=$l") for l in 0:R]
tensors = ITensor[]
for n in 1:R
push!(tensors, onehot(links[n] => 1, links[n + 1] => 1, sites[n] => indices[n]))
end
tensors[1] *= onehot(links[1] => 1)
tensors[end] *= onehot(links[end] => 1)
return MPS(tensors)
end
function _find_target_sites(M::MPS; sitessrc=nothing, tag="")
_find_target_sites(siteinds(M); sitessrc, tag)
end
function _find_target_sites(sites::AbstractVector{Index{T}}; sitessrc=nothing, tag="") where {T}
if tag == "" && sitessrc === nothing
error("tag or sitesrc must be specified")
elseif tag != "" && sitessrc !== nothing
error("tag and sitesrc are exclusive")
end
# Set input site indices
if tag != ""
sitepos = findallsites_by_tag(sites; tag=tag)
target_sites = [sites[p] for p in sitepos]
elseif sitessrc !== nothing
target_sites = sitessrc
sitepos = Int[findfirst(x->x==s, sites) for s in sitessrc]
end
return sitepos, target_sites
end
function replace_siteinds_part!(M::MPS, sitesold, sitesnew)
length(sitesold) == length(sitesnew) ||
error("Length mismatch between sitesold and sitesnew")
for i in eachindex(sitesold)
p = findsite(M, sitesold[i])
if p === nothing
error("Not found $(sitesold[i])")
end
replaceinds!(M[p], sitesold[i] => sitesnew[i])
end
return nothing
end
"""
Connect two MPS's
ITensor objects are deepcopied.
"""
function _directprod(M1::MPS, Mx::MPS...)::MPS
M2 = Mx[1]
l = Index(1, "Link")
tensors1 = [deepcopy(x) for x in M1]
tensors2 = [deepcopy(x) for x in M2]
tensors1[end] = ITensor(ITensors.data(last(tensors1)), [inds(last(tensors1))..., l])
tensors2[1] = ITensor(ITensors.data(first(tensors2)), [l, inds(first(tensors2))...])
M12 = MPS([tensors1..., tensors2...])
if length(Mx) == 1
return M12
else
return _directprod(M12, Mx[2:end]...)
end
end
function rearrange_siteinds(M::AbstractMPS, sites::Vector{Vector{Index{T}}})::MPS where {T}
sitesold = siteinds(MPO(collect(M)))
Set(Iterators.flatten(sites)) == Set(Iterators.flatten(sitesold)) ||
error("siteinds do not match $(sites) != $(sitesold)")
t = ITensor(1)
tensors = Vector{ITensor}(undef, length(sites))
tensors_old = collect(M)
for (i, site) in enumerate(sites)
for ind in site
if ind ∈ inds(t)
continue
end
contract_until = findfirst(x -> ind ∈ Set(collect(x)), inds.(tensors_old))
contract_until !== nothing || error("ind $ind not found")
for j in 1:contract_until
t *= tensors_old[j]
end
for _ in 1:contract_until
popfirst!(tensors_old)
end
end
linds = if i > 1
vcat(only(commoninds(t, tensors[i - 1])), sites[i])
else
sites[i]
end
tensors[i], t, _ = qr(t, linds)
end
tensors[end] *= t
cleanup_linkinds!(MPS(tensors))
end
"""
Makes an MPS/MPO diagonal for a specified a site index `s`.
On return, the data will be deep copied and the target core tensor will be diagonalized with an additional site index `s'`.
"""
function makesitediagonal(M::AbstractMPS, site::Index{T})::MPS where {T}
M_ = deepcopy(MPO(collect(M)))
target_site::Int = only(findsites(M_, site))
M_[target_site] = _asdiagonal(M_[target_site], site)
return MPS(collect(M_))
end
function makesitediagonal(M::AbstractMPS, tag::String)::MPS
M_ = deepcopy(MPO(collect(M)))
sites = siteinds(M_)
target_positions = findallsites_by_tag(siteinds(M_); tag=tag)
for t in eachindex(target_positions)
i, j = target_positions[t]
M_[i] = _asdiagonal(M_[i], sites[i][j])
end
return MPS(collect(M_))
end
"""
Extract diagonal components
"""
function extractdiagonal(M::AbstractMPS, tag::String)::MPS
M_ = deepcopy(MPO(collect(M)))
sites = siteinds(M_)
target_positions = findallsites_by_tag(siteinds(M_); tag=tag)
for t in eachindex(target_positions)
i, j = target_positions[t]
M_[i] = _extract_diagonal(M_[i], sites[i][j], sites[i][j]')
end
return MPS(collect(M_))
end
function _extract_diagonal(t, site::Index{T}, site2::Index{T}) where {T<:Number}
dim(site) == dim(site2) || error("Dimension mismatch")
restinds = uniqueinds(inds(t), site, site2)
newdata = zeros(eltype(t), dim.(restinds)..., dim(site))
olddata = Array(t, restinds..., site, site2)
for i in 1:dim(site)
newdata[.., i] = olddata[.., i, i]
end
return ITensor(newdata, restinds..., site)
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 10094 | @testitem "binaryop_tests.jl/_binaryop" begin
using Test
using ITensors
ITensors.disable_warn_order()
using Quantics
import Random
@testset "_binaryop" for rev_carrydirec in [true], nbit in 2:3
Random.seed!(1)
# For a = +/- 1, b = +/- 1, c = +/- 1, d = +/- 1,
# x' = a * x + b * y
# y' = c * x + d * y
# f(x, y) = g(x', y')
# excluding a + b == -2 || c + d == -2
if rev_carrydirec
# x1, y1, x2, y2, ...
sites = [Index(2, "Qubit, $name=$n") for n in 1:nbit for name in ["x", "y"]]
else
# xR, yR, xR-1, yR-1, ...
sites = [Index(2, "Qubit, $name=$n") for n in reverse(1:nbit)
for name in ["x", "y"]]
end
# x1, x2, ...
sitesx = [sites[findfirst(x -> hastags(x, "x=$n"), sites)] for n in 1:nbit]
# y1, y2, ...
sitesy = [sites[findfirst(x -> hastags(x, "y=$n"), sites)] for n in 1:nbit]
rsites = reverse(sites)
for a in -1:1, b in -1:1, c in -1:1, d in -1:1, bc_x in [1, -1], bc_y in [1, -1]
g = randomMPS(sites)
M = Quantics._binaryop_mpo(sites, [(a, b), (c, d)], [(1, 2), (1, 2)];
rev_carrydirec=rev_carrydirec, bc=[bc_x, bc_y])
f = apply(M, g)
# f[x_R, ..., x_1, y_R, ..., y_1] and f[x, y]
f_arr = Array(reduce(*, f), vcat(reverse(sitesx), reverse(sitesy)))
f_vec = reshape(f_arr, 2^nbit, 2^nbit)
# g[x_R, ..., x_1, y_R, ..., y_1] and g[x, y]
g_arr = Array(reduce(*, g), vcat(reverse(sitesx), reverse(sitesy)))
g_vec = reshape(g_arr, 2^nbit, 2^nbit)
function prime_xy(x, y)
0 <= x < 2^nbit || error("something went wrong")
0 <= y < 2^nbit || error("something went wrong")
xp_ = a * x + b * y
yp_ = c * x + d * y
nmodx, xp = divrem(xp_, 2^nbit, RoundDown)
nmody, yp = divrem(yp_, 2^nbit, RoundDown)
return xp, yp, bc_x^nmodx, bc_y^nmody
end
f_vec_ref = similar(f_vec)
for x in 0:(2^nbit - 1), y in 0:(2^nbit - 1)
xp, yp, sign_x, sign_y = prime_xy(x, y)
f_vec_ref[x + 1, y + 1] = g_vec[xp + 1, yp + 1] * sign_x * sign_y
end
@test f_vec_ref ≈ f_vec
end
end
end
@testitem "binaryop_tests.jl/affinetransform" begin
using Test
using ITensors
ITensors.disable_warn_order()
using Quantics
import Random
@testset "affinetransform" for rev_carrydirec in [true, false], nbit in 2:3
Random.seed!(1)
# For a, b, c, d = +1, -1, 0,
# x' = a * x + b * y + s1
# y' = c * x + d * y + s2
# f(x, y) = g(x', y')
if rev_carrydirec
# x1, y1, x2, y2, ...
sites = [Index(2, "Qubit, $name=$n") for n in 1:nbit for name in ["x", "y"]]
else
# xR, yR, xR-1, yR-1, ...
sites = [Index(2, "Qubit, $name=$n") for n in reverse(1:nbit)
for name in ["x", "y"]]
end
# x1, x2, ...
sitesx = [sites[findfirst(x -> hastags(x, "x=$n"), sites)] for n in 1:nbit]
# y1, y2, ...
sitesy = [sites[findfirst(x -> hastags(x, "y=$n"), sites)] for n in 1:nbit]
shift = rand((-2 * 2^nbit):(2 * 2^nbit), 2)
for a in -1:1, b in -1:1, c in -1:1, d in -1:1, bc_x in [1, -1], bc_y in [1, -1]
g = randomMPS(sites)
f = Quantics.affinetransform(g, ["x", "y"],
[Dict("x" => a, "y" => b), Dict("x" => c, "y" => d)],
shift, [bc_x, bc_y]; cutoff=1e-25)
# f[x_R, ..., x_1, y_R, ..., y_1] and f[x, y]
f_arr = Array(reduce(*, f), vcat(reverse(sitesx), reverse(sitesy)))
f_vec = reshape(f_arr, 2^nbit, 2^nbit)
# g[x_R, ..., x_1, y_R, ..., y_1] and g[x, y]
g_arr = Array(reduce(*, g), vcat(reverse(sitesx), reverse(sitesy)))
g_vec = reshape(g_arr, 2^nbit, 2^nbit)
function prime_xy(x, y)
0 <= x < 2^nbit || error("something went wrong")
0 <= y < 2^nbit || error("something went wrong")
xp_ = a * x + b * y + shift[1]
yp_ = c * x + d * y + shift[2]
nmodx, xp = divrem(xp_, 2^nbit, RoundDown)
nmody, yp = divrem(yp_, 2^nbit, RoundDown)
return xp, yp, bc_x^nmodx, bc_y^nmody
end
f_vec_ref = similar(f_vec)
for x in 0:(2^nbit - 1), y in 0:(2^nbit - 1)
xp, yp, sign_x, sign_y = prime_xy(x, y)
f_vec_ref[x + 1, y + 1] = g_vec[xp + 1, yp + 1] * sign_x * sign_y
end
@test f_vec_ref ≈ f_vec
end
end
end
@testitem "binaryop_tests.jl/affinetransform_three_vars" begin
using Test
using ITensors
ITensors.disable_warn_order()
using Quantics
import Random
affinetransform_testsets = []
# x' = x + y
# y' = y + z
# z' = x + z
push!(affinetransform_testsets, [1 1 0; 0 1 1; 1 0 1])
# x' = -x - y
# y' = y + z
# z' = x + z
push!(affinetransform_testsets, [-1 -1 0; 0 1 1; 1 0 1])
# x' = -x + z
# y' = y + z
# z' = x + z
push!(affinetransform_testsets, [-1 0 1; 0 1 1; 1 0 1])
# x' = y + z
# y' = y + z
# z' = x + z
push!(affinetransform_testsets, [0 1 1; 0 1 1; 1 0 1])
# x' = y - z
# y' = y
# z' = x
push!(affinetransform_testsets, [0 1 -1; 0 1 0; 1 0 0])
@testset "affinetransform_three_vars" for rev_carrydirec in [true, false],
bc_x in [1, -1], bc_y in [1, -1],
bc_z in [1, -1], nbit in 2:3,
affmat in affinetransform_testsets
#@testset "affinetransform_three_var" for rev_carrydirec in [true], bc_x in [1], bc_y in [1], bc_z in [1], nbit in [2], affmat in affinetransform_testsets
Random.seed!(1234)
varnames = ["x", "y", "z", "K"] # "K" is not involved in transform
# Read coefficient matrix
coeffs_dic = Dict{String,Int}[]
for newvar in 1:3
@test all(abs.(affmat[newvar, :]) .<= 1)
@test sum(abs.(affmat[newvar, :])) <= 2
@test sum(abs.(affmat[newvar, :])) > 0
coeffs = Dict{String,Int}()
for oldvar in 1:3
if affmat[newvar, oldvar] != 0
coeffs[varnames[oldvar]] = affmat[newvar, oldvar]
end
end
if length(coeffs) == 1
for oldvar in 1:3
if !(varnames[oldvar] ∈ keys(coeffs))
coeffs[varnames[oldvar]] = 0
break
end
end
end
@test length(coeffs) == 2
push!(coeffs_dic, coeffs)
end
if rev_carrydirec
# x1, y1, z1, x2, y2, z2, ...
sites = [Index(2, "Qubit, $name=$n") for n in 1:nbit for name in varnames]
else
# xR, yR, zR, xR-1, yR-1, zR-1...
sites = [Index(2, "Qubit, $name=$n") for n in reverse(1:nbit)
for name in varnames]
end
# x1, x2, ...
sitesx = [sites[findfirst(x -> hastags(x, "x=$n"), sites)] for n in 1:nbit]
# y1, y2, ...
sitesy = [sites[findfirst(x -> hastags(x, "y=$n"), sites)] for n in 1:nbit]
# z1, z2, ...
sitesz = [sites[findfirst(x -> hastags(x, "z=$n"), sites)] for n in 1:nbit]
# K1, K2, ...
sitesK = [sites[findfirst(x -> hastags(x, "K=$n"), sites)] for n in 1:nbit]
shift = rand((-2 * 2^nbit):(2 * 2^nbit), 3)
g = randomMPS(sites)
f = Quantics.affinetransform(g, ["x", "y", "z"],
coeffs_dic,
shift, [bc_x, bc_y, bc_z]; cutoff=1e-25)
# f[x_R, ..., x_1, y_R, ..., y_1, z_R, ..., z_1] and f[x, y, z]
f_arr = Array(reduce(*, f),
vcat(reverse(sitesx), reverse(sitesy), reverse(sitesz),
reverse(sitesK)))
f_vec = reshape(f_arr, 2^nbit, 2^nbit, 2^nbit, 2^nbit)
# g[x'_R, ..., x'_1, y'_R, ..., y'_1, z'_R, ..., z'_1] and g[x', y', z']
g_arr = Array(reduce(*, g),
vcat(reverse(sitesx), reverse(sitesy), reverse(sitesz),
reverse(sitesK)))
g_vec = reshape(g_arr, 2^nbit, 2^nbit, 2^nbit, 2^nbit)
function prime_xy(x, y, z)
xp_, yp_, zp_ = affmat * [x, y, z] .+ shift
nmodx, xp = divrem(xp_, 2^nbit, RoundDown)
nmody, yp = divrem(yp_, 2^nbit, RoundDown)
nmodz, zp = divrem(zp_, 2^nbit, RoundDown)
return xp, yp, zp, bc_x^nmodx, bc_y^nmody, bc_z^nmodz
end
f_vec_ref = similar(f_vec)
for x in 0:(2^nbit - 1), y in 0:(2^nbit - 1), z in 0:(2^nbit - 1)
xp, yp, zp, sign_x, sign_y, sign_z = prime_xy(x, y, z)
f_vec_ref[x + 1, y + 1, z + 1, :] .= g_vec[xp + 1, yp + 1, zp + 1, :] * sign_x *
sign_y * sign_z
end
@test f_vec_ref ≈ f_vec
end
end
@testitem "binaryop_tests.jl/shiftop" begin
using Test
using ITensors
ITensors.disable_warn_order()
using Quantics
import Random
@testset "shiftop" for R in [3], bc in [1, -1]
sites = [Index(2, "Qubit, x=$n") for n in 1:R]
g = randomMPS(sites)
for shift in [0, 1, 2, 2^R - 1]
M = Quantics._shift_mpo(sites, shift; bc=bc)
f = apply(M, g)
f_vec = vec(Array(reduce(*, f), reverse(sites)))
g_vec = vec(Array(reduce(*, g), reverse(sites)))
f_vec_ref = similar(f_vec)
for i in 1:(2^R)
ishifted = mod1(i + shift, 2^R)
sign = ishifted == i + shift ? 1 : bc
f_vec_ref[i] = g_vec[ishifted] * sign
end
@test f_vec_ref ≈ f_vec
end
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 3645 |
@testitem "fouriertransform_tests.jl/qft_mpo" begin
using Test
using Quantics
using ITensors
# A brute-force implementation of _qft (only for tests)
function _qft_ref(sites; cutoff::Float64=1e-14, sign::Int=1)
abs(sign) == 1 || error("sign must either 1 or -1")
nbit = length(sites)
N = 2^nbit
sites = noprime(sites)
tmat = zeros(ComplexF64, N, N)
for t in 0:(N - 1), x in 0:(N - 1)
tmat[t + 1, x + 1] = exp(sign * im * 2π * t * x / N)
end
# `tmat`: (y_1, ..., y_N, x_1, ..., x_N)
tmat ./= sqrt(N)
tmat = reshape(tmat, ntuple(x -> 2, 2 * nbit))
trans_t = ITensor(tmat, reverse(sites)..., prime(sites)...)
M = MPO(trans_t, sites; cutoff=cutoff)
return M
end
@testset "qft_mpo" for sign in [1, -1], nbit in [1, 2, 3]
N = 2^nbit
sites = siteinds("Qubit", nbit)
M = Quantics._qft(sites; sign=sign)
M_ref = _qft_ref(sites; sign=sign)
@test Array(reduce(*, M), vcat(sites, sites')) ≈
Array(reduce(*, M_ref), vcat(sites, sites'))
end
end
@testitem "fouriertransform_tests.jl/fouriertransform" begin
using Test
using Quantics
using ITensors
function _ft_1d_ref(X, sign, originx, origink)
N = length(X)
Y = zeros(ComplexF64, N)
for k in 1:N
for x in 1:N
Y[k] += exp(sign * im * 2π * (k + origink - 1) * (x + originx - 1) / N) *
X[x]
end
end
Y ./= sqrt(N)
return Y
end
@testset "fouriertransform_1d" for sign in [1, -1], nbit in [2, 3, 4], originx in [0.1],
originy in [-0.2]
N = 2^nbit
sitesx = [Index(2, "Qubit,x=$x") for x in 1:nbit]
sitesk = [Index(2, "Qubit,k=$k") for k in 1:nbit]
# X(x)
X = randomMPS(sitesx)
X_vec = Array(reduce(*, X), reverse(sitesx))
# Y(k)
Y = Quantics.fouriertransform(X; sign=sign, tag="x", sitesdst=sitesk,
originsrc=originx, origindst=originy)
Y_vec_ref = _ft_1d_ref(X_vec, sign, originx, originy)
Y_vec = vec(Array(reduce(*, Y), reverse(sitesk)))
@test Y_vec ≈ Y_vec_ref
end
function _ft_2d_ref(F::Matrix, sign)
N = size(F, 1)
G = zeros(ComplexF64, N, N)
for ky in 1:N, kx in 1:N
for y in 1:N, x in 1:N
G[kx, ky] += exp(sign * im * 2π * (kx - 1) * (x - 1) / N) *
exp(sign * im * 2π * (ky - 1) * (y - 1) / N) * F[x, y]
end
end
G ./= N
return G
end
@testset "fouriertransform_2d" for sign in [1, -1], nbit in [2, 3]
N = 2^nbit
sitesx = [Index(2, "Qubit,x=$x") for x in 1:nbit]
sitesy = [Index(2, "Qubit,y=$y") for y in 1:nbit]
siteskx = [Index(2, "Qubit,kx=$kx") for kx in 1:nbit]
sitesky = [Index(2, "Qubit,ky=$ky") for ky in 1:nbit]
sitesin = collect(Iterators.flatten(zip(sitesx, sitesy)))
# F(x, y)
# F(x_1, y_1, ..., x_R, y_R)
F = randomMPS(sitesin)
F_mat = reshape(Array(reduce(*, F), vcat(reverse(sitesx), reverse(sitesy))), N, N)
# G(kx, ky)
# G(kx_R, ky_R, ..., kx_1, ky_1)
G_ = Quantics.fouriertransform(F; sign=sign, tag="x", sitesdst=siteskx)
G = Quantics.fouriertransform(G_; sign=sign, tag="y", sitesdst=sitesky)
G_mat_ref = _ft_2d_ref(F_mat, sign)
G_mat = reshape(Array(reduce(*, G), vcat(reverse(siteskx), reverse(sitesky))), N, N)
@test G_mat ≈ G_mat_ref
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 3603 | @testitem "imaginarytime_tests.jl/imaginarytime" begin
using Test
using Quantics
import ITensors: siteinds, Index
import ITensors
import SparseIR: Fermionic, Bosonic, FermionicFreq, valueim
function _test_data_imaginarytime(nbit, β)
ω = 0.5
N = 2^nbit
halfN = 2^(nbit - 1)
# Tau
gtau(τ) = -exp(-ω * τ) / (1 + exp(-ω * β))
@assert gtau(0.0) + gtau(β) ≈ -1
τs = collect(LinRange(0.0, β, N + 1))[1:(end - 1)]
gtau_smpl = Vector{ComplexF64}(gtau.(τs))
# Matsubra
giv(v::FermionicFreq) = 1 / (valueim(v, β) - ω)
vs = FermionicFreq.(2 .* collect((-halfN):(halfN - 1)) .+ 1)
giv_smpl = giv.(vs)
return gtau_smpl, giv_smpl
end
@testset "decompose" begin
β = 2.0
nbit = 10
nτ = 2^nbit
gtau_smpl, giv_smpl = _test_data_imaginarytime(nbit, β)
sites = siteinds("Qubit", nbit)
gtau_mps = Quantics.decompose_gtau(gtau_smpl, sites; cutoff=1e-20)
gtau_smpl_reconst = vec(Array(reduce(*, gtau_mps), reverse(sites)...))
@test gtau_smpl_reconst ≈ gtau_smpl
end
@testset "ImaginaryTimeFT.to_wn" begin
ITensors.set_warn_order(100)
β = 1.5
nbit = 6
nτ = 2^nbit
gtau_smpl, giv_smpl = _test_data_imaginarytime(nbit, β)
sitesτ = [Index(2, "Qubit,τ=$n") for n in 1:nbit]
sitesiω = [Index(2, "Qubit,iω=$n") for n in 1:nbit]
gtau_mps = Quantics.decompose_gtau(gtau_smpl, sitesτ; cutoff=1e-20)
giv_mps = Quantics.to_wn(Fermionic(), gtau_mps, β; cutoff=1e-20, tag="τ",
sitesdst=sitesiω)
giv = vec(Array(reduce(*, giv_mps), reverse(sitesiω)...))
@test maximum(abs, giv - giv_smpl) < 2e-2
end
@testset "ImaginaryTimeFT.to_tau" begin
ITensors.set_warn_order(100)
β = 1.5
nbit = 8
nτ = 2^nbit
gtau_smpl, giv_smpl = _test_data_imaginarytime(nbit, β)
sitesτ = [Index(2, "Qubit,τ=$n") for n in 1:nbit]
sitesiω = [Index(2, "Qubit,iω=$n") for n in 1:nbit]
giv_mps = Quantics.decompose_giv(giv_smpl, sitesiω; cutoff=1e-20)
gtau_mps = Quantics.to_tau(Fermionic(), giv_mps, β; cutoff=1e-20, tag="iω",
sitesdst=sitesτ)
gtau = vec(Array(reduce(*, gtau_mps), reverse(sitesτ)...))
# There is ocillation around tau = 0, beta.
@test maximum(abs, (gtau - gtau_smpl)[trunc(Int, 0.2 * nτ):trunc(Int, 0.8 * nτ)]) <
1e-2
end
end
@testitem "imaginarytime_tests.jl/poletomps" begin
using Test
using Quantics
import ITensors: siteinds, Index
import ITensors
import SparseIR: Fermionic, Bosonic, FermionicFreq, valueim
@testset "poletomps" begin
nqubit = 10
sites = siteinds("Qubit", nqubit)
β = 10.0
ω = 1.2
gtau = Quantics.poletomps(sites, β, ω)
gtauvec = vec(Array(reduce(*, gtau), reverse(sites)))
gtauf(τ) = -exp(-τ * ω) / (1 + exp(-β * ω))
gtauref = gtauf.(LinRange(0, β, 2^nqubit + 1)[1:(end - 1)])
@test maximum(abs, gtauref .- gtauvec) < 1e-14
end
@testset "poletomps_negative_pole" begin
nqubit = 16
sites = siteinds("Qubit", nqubit)
β = 1000.0
ω = -10.0
gtau = Quantics.poletomps(Fermionic(), sites, β, ω)
gtauvec = vec(Array(reduce(*, gtau), reverse(sites)))
gtauf(τ) = -exp((β - τ) * ω)
gtauref = gtauf.(LinRange(0, β, 2^nqubit + 1)[1:(end - 1)])
@test maximum(abs, gtauref .- gtauvec) < 1e-14
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 722 | @testitem "mps_tests.jl/onemps" begin
using Test
import Quantics
using ITensors
@testset "onemps" begin
nbit = 3
sites = siteinds("Qubit", nbit)
M = Quantics.onemps(Float64, sites)
@test vec(Array(reduce(*, M), sites)) ≈ ones(2^nbit)
end
end
@testitem "mps_tests.jl/expqtt" begin
using Test
import Quantics
using ITensors
@testset "expqtt" begin
R = 10
sites = siteinds("Qubit", 10)
f = Quantics.expqtt(sites, -1.0)
f_values = vec(Array(reduce(*, f), reverse(sites)))
xs = collect(LinRange(0, 1, 2^R + 1)[1:(end - 1)])
f_values_ref = (x -> exp(-x)).(xs)
@test f_values ≈ f_values_ref
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 5026 | @testitem "test_mul.jl/preprocess_matmul" begin
using Test
import Quantics
using ITensors
@testset "_preprocess_matmul" begin
N = 2
sitesx = [Index(2, "x=$n") for n in 1:N]
sitesy = [Index(2, "y=$n") for n in 1:N]
sitesz = [Index(2, "z=$n") for n in 1:N]
sites1 = collect(Iterators.flatten(zip(sitesx, sitesy)))
sites2 = collect(Iterators.flatten(zip(sitesy, sitesz)))
M1 = Quantics.asMPO(randomMPS(sites1))
M2 = Quantics.asMPO(randomMPS(sites2))
mul = Quantics.MatrixMultiplier(sitesx, sitesy, sitesz)
M1, M2 = Quantics.preprocess(mul, M1, M2)
flag = true
for n in 1:N
flag = flag && hasinds(M1[n], sitesx[n], sitesy[n])
flag = flag && hasinds(M2[n], sitesy[n], sitesz[n])
end
@test flag
end
@testset "postprocess_matmul" begin
N = 2
sitesx = [Index(2, "x=$n") for n in 1:N]
sitesy = [Index(2, "y=$n") for n in 1:N]
sitesz = [Index(2, "z=$n") for n in 1:N]
mul = Quantics.MatrixMultiplier(sitesx, sitesy, sitesz)
links = [Index(1, "Link,l=$l") for l in 0:N]
M = MPO(N)
for n in 1:N
M[n] = randomITensor(links[n], links[n + 1], sitesx[n], sitesz[n])
end
M = Quantics.postprocess(mul, M)
flag = true
for n in 1:N
flag = flag && hasind(M[2 * n - 1], sitesx[n])
flag = flag && hasind(M[2 * n], sitesz[n])
end
@test flag
end
end
@testitem "mul_tests.jl/matmul" begin
using Test
import Quantics
using ITensors
@testset "matmul" for T in [Float64, ComplexF64]
N = 3
sitesx = [Index(2, "x=$n") for n in 1:N]
sitesy = [Index(2, "y=$n") for n in 1:N]
sitesz = [Index(2, "z=$n") for n in 1:N]
mul = Quantics.MatrixMultiplier(sitesx, sitesy, sitesz)
sites1 = collect(Iterators.flatten(zip(sitesx, sitesy)))
sites2 = collect(Iterators.flatten(zip(sitesy, sitesz)))
M1 = Quantics.asMPO(randomMPS(T, sites1))
M2 = Quantics.asMPO(randomMPS(T, sites2))
# preprocess
M1, M2 = Quantics.preprocess(mul, M1, M2)
# MPO-MPO contraction
M = Quantics.asMPO(contract(M1, M2; alg="naive"))
# postprocess
M = Quantics.postprocess(mul, M)
M_mat_reconst = reshape(Array(reduce(*, M), [reverse(sitesx)..., reverse(sitesz)]),
2^N, 2^N)
# Reference data
M1_mat = reshape(Array(reduce(*, M1), [reverse(sitesx)..., reverse(sitesy)]), 2^N,
2^N)
M2_mat = reshape(Array(reduce(*, M2), [reverse(sitesy)..., reverse(sitesz)]), 2^N,
2^N)
M_mat_ref = M1_mat * M2_mat
@test M_mat_ref ≈ M_mat_reconst
end
@testset "elementwisemul" for T in [Float64, ComplexF64]
N = 5
sites = [Index(2, "n=$n") for n in 1:N]
mul = Quantics.ElementwiseMultiplier(sites)
M1_ = randomMPS(T, sites)
M2_ = randomMPS(T, sites)
M1 = Quantics.asMPO(M1_)
M2 = Quantics.asMPO(M2_)
# preprocess
M1, M2 = Quantics.preprocess(mul, M1, M2)
# MPO-MPO contraction
M = Quantics.asMPO(contract(M1, M2; alg="naive"))
# postprocess
M = Quantics.postprocess(mul, M)
# Comparison with reference data
M_reconst = Array(reduce(*, M), sites)
M1_reconst = Array(reduce(*, M1_), sites)
M2_reconst = Array(reduce(*, M2_), sites)
@test M_reconst ≈ M1_reconst .* M2_reconst
end
end
@testitem "mul_tests.jl/batchedmatmul" begin
using Test
import Quantics
using ITensors
"""
Reconstruct 3D matrix
"""
function _tomat3(a)
sites = siteinds(a)
N = length(sites)
Nreduced = N ÷ 3
sites_ = [sites[1:3:N]..., sites[2:3:N]..., sites[3:3:N]...]
return reshape(Array(reduce(*, a), sites_), 2^Nreduced, 2^Nreduced, 2^Nreduced)
end
@testset "batchedmatmul" for T in [Float64, ComplexF64]
"""
C(x, z, k) = sum_y A(x, y, k) * B(y, z, k)
"""
nbit = 2
D = 2
sx = [Index(2, "Qubit,x=$n") for n in 1:nbit]
sy = [Index(2, "Qubit,y=$n") for n in 1:nbit]
sz = [Index(2, "Qubit,z=$n") for n in 1:nbit]
sk = [Index(2, "Qubit,k=$n") for n in 1:nbit]
sites_a = collect(Iterators.flatten(zip(sx, sy, sk)))
sites_b = collect(Iterators.flatten(zip(sy, sz, sk)))
a = randomMPS(T, sites_a; linkdims=D)
b = randomMPS(T, sites_b; linkdims=D)
# Reference data
a_arr = _tomat3(a)
b_arr = _tomat3(b)
ab_arr = zeros(T, 2^nbit, 2^nbit, 2^nbit)
for k in 1:(2^nbit)
ab_arr[:, :, k] .= a_arr[:, :, k] * b_arr[:, :, k]
end
ab = Quantics.automul(a, b; tag_row="x", tag_shared="y", tag_col="z", alg="fit")
ab_arr_reconst = _tomat3(ab)
@test ab_arr ≈ ab_arr_reconst
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 84 | using ReTestItems: runtests, @testitem
using Quantics: Quantics
runtests(Quantics)
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 1566 | @testitem "tag_tests.jl/tag" begin
using Test
import Quantics
using ITensors
@testset "findallsites_by_tag" for tag in ["x", "y"]
nbit = 4
sites = [Index(2, "Qubit,$(tag)=$x") for x in 1:nbit]
@test Quantics.findallsites_by_tag(sites; tag=tag) == [1, 2, 3, 4]
@test isempty(Quantics.findallsites_by_tag(sites; tag="notfound"))
invalid_tag = "$(tag)="
@test_throws "Invalid tag: $(tag)=" Quantics.findallsites_by_tag(sites,
tag=invalid_tag)
invalid_sites = [Index(2, "Qubit,$(tag)=1"), Index(2, "Qubit,$(tag)=1")]
@test_throws "with $(tag)=1!" Quantics.findallsites_by_tag(invalid_sites, tag=tag)
@test_throws "Invalid tag: $(tag)=" Quantics.findallsites_by_tag(invalid_sites,
tag="$(tag)=")
end
@testset "findallsiteinds_by_tag" for tag in ["x", "y"]
nbit = 4
sites = [Index(2, "Qubit,$(tag)=$x") for x in 1:nbit]
@test Quantics.findallsiteinds_by_tag(sites; tag=tag) == sites
@test isempty(Quantics.findallsiteinds_by_tag(sites; tag="notfound"))
invalid_tag = "$(tag)="
@test_throws "Invalid tag: $(tag)=" Quantics.findallsiteinds_by_tag(sites,
tag=invalid_tag)
invalid_sites = [Index(2, "Qubit,$(tag)=1"), Index(2, "Qubit,$(tag)=1")]
@test_throws "with $(tag)=1!" Quantics.findallsiteinds_by_tag(invalid_sites,
tag=tag)
@test_throws "Invalid tag: $(tag)=" Quantics.findallsiteinds_by_tag(invalid_sites,
tag="$(tag)=")
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 129 | @testitem begin
using Aqua
import Quantics
@testset "Aqua" begin
Aqua.test_stale_deps(Quantics)
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 8808 |
@testitem "transformer_tests.jl/functions" begin
using Test
import Quantics
using ITensors
using LinearAlgebra
@testset "upper_lower_triangle" for upper_or_lower in [:upper, :lower]
R = 3
sites = siteinds("Qubit", R)
trimat = Quantics.upper_lower_triangle_matrix(sites, 1.0;
upper_or_lower=upper_or_lower)
trimatdata = Array(reduce(*, trimat), [reverse(sites')..., reverse(sites)...])
trimatdata = reshape(trimatdata, 2^R, 2^R)
ref = upper_or_lower == :lower ? [Float64(i > j) for i in 1:(2^R), j in 1:(2^R)] :
[Float64(i < j) for i in 1:(2^R), j in 1:(2^R)]
@test trimatdata ≈ ref
end
@testset "cusum" begin
R = 3
sites = siteinds("Qubit", R)
UT = Quantics.upper_lower_triangle_matrix(sites, 1.0; upper_or_lower=:lower)
f = Quantics.expqtt(sites, -1.0)
f_values = vec(Array(reduce(*, f), reverse(sites)))
xs = collect(LinRange(0, 1, 2^R + 1)[1:(end - 1)])
g = apply(UT, f)
g_values = vec(Array(reduce(*, g), reverse(sites)))
g_values_ref = cumsum(f_values) .- f_values # Second term remove the own values
@test g_values ≈ g_values_ref
end
@testset "flipop" for nbit in 2:3, rev_carrydirec in [true, false], bc in [1, -1]
sites = siteinds("Qubit", nbit)
g = randomMPS(rev_carrydirec ? sites : reverse(sites))
op = Quantics.flipop(siteinds(g); rev_carrydirec=rev_carrydirec, bc=bc)
f = apply(op, g; alg="naive")
g_reconst = vec(Array(reduce(*, g), reverse(sites)))
f_reconst = vec(Array(reduce(*, f), reverse(sites)))
f_ref = similar(f_reconst)
for i in 0:(2^nbit - 1)
nmod, i_ = divrem(2^nbit - i, 2^nbit, RoundDown)
f_ref[i + 1] = g_reconst[i_ + 1] * (bc^nmod)
end
@test f_reconst ≈ f_ref
end
end
@testitem "transformer_tests.jl/reverseaxis" begin
using Test
import Quantics
using ITensors
using LinearAlgebra
@testset "reverseaxis" for bc in [1], nbit in 2:2, rev_carrydirec in [true, false]
sitesx = [Index(2, "x=$x") for x in 1:nbit]
sites = rev_carrydirec ? sitesx : reverse(sitesx)
g = randomMPS(sites)
f = Quantics.reverseaxis(g; tag="x", alg="naive", bc=bc)
g_reconst = vec(Array(reduce(*, g), reverse(sitesx)))
f_reconst = vec(Array(reduce(*, f), reverse(sitesx)))
f_ref = similar(f_reconst)
for i in 1:(2^nbit)
f_ref[i] = g_reconst[mod(2^nbit - (i - 1), 2^nbit) + 1]
end
f_ref[1] *= bc
@test f_reconst ≈ f_ref
end
@testset "reverseaxis2" for nbit in 2:3, rev_carrydirec in [true, false]
N = 2^nbit
sitesx = [Index(2, "x=$x") for x in 1:nbit]
sitesy = [Index(2, "y=$y") for y in 1:nbit]
if rev_carrydirec
sites = collect(Iterators.flatten(zip(sitesx, sitesy)))
else
sites = collect(Iterators.flatten(zip(reverse(sitesx), reverse(sitesy))))
end
g = randomMPS(sites)
function _reconst(M)
arr = Array(reduce(*, M), [reverse(sitesx)..., reverse(sitesy)...])
return reshape(arr, N, N)
end
g_reconst = _reconst(g)
fx = Quantics.reverseaxis(g; tag="x", alg="naive")
fx_reconst = _reconst(fx)
fy = Quantics.reverseaxis(g; tag="y", alg="naive")
fy_reconst = _reconst(fy)
fx_ref = similar(fx_reconst)
fy_ref = similar(fy_reconst)
for j in 0:(N - 1), i in 0:(N - 1)
fx_ref[i + 1, j + 1] = g_reconst[mod(N - i, N) + 1, j + 1]
fy_ref[i + 1, j + 1] = g_reconst[i + 1, mod(N - j, N) + 1]
end
@test fx_reconst ≈ fx_ref
@test fy_reconst ≈ fy_ref
end
#@testset "reverseaxis3" for nbit in 2:3, rev_carrydirec in [true, false]
@testset "reverseaxis3" for nbit in [2], rev_carrydirec in [true]
N = 2^nbit
sitesx = [Index(2, "x=$x") for x in 1:nbit]
sitesy = [Index(2, "y=$y") for y in 1:nbit]
sitesz = [Index(2, "z=$z") for z in 1:nbit]
if rev_carrydirec
sites = collect(Iterators.flatten(zip(sitesx, sitesy, sitesz)))
else
sites = collect(Iterators.flatten(zip(reverse(sitesx), reverse(sitesy),
reverse(sitesz))))
end
g = randomMPS(sites)
function _reconst(M)
arr = Array(reduce(*, M),
[reverse(sitesx)..., reverse(sitesy)..., reverse(sitesz)...])
return reshape(arr, N, N, N)
end
g_reconst = _reconst(g)
fx = Quantics.reverseaxis(g; tag="x", alg="naive")
fx_reconst = _reconst(fx)
fy = Quantics.reverseaxis(g; tag="y", alg="naive")
fy_reconst = _reconst(fy)
fz = Quantics.reverseaxis(g; tag="z", alg="naive")
fz_reconst = _reconst(fz)
fx_ref = similar(fx_reconst)
fy_ref = similar(fy_reconst)
fz_ref = similar(fz_reconst)
for k in 0:(N - 1), j in 0:(N - 1), i in 0:(N - 1)
fx_ref[i + 1, j + 1, k + 1] = g_reconst[mod(N - i, N) + 1, j + 1, k + 1]
fy_ref[i + 1, j + 1, k + 1] = g_reconst[i + 1, mod(N - j, N) + 1, k + 1]
fz_ref[i + 1, j + 1, k + 1] = g_reconst[i + 1, j + 1, mod(N - k, N) + 1]
end
@test fx_reconst ≈ fx_ref
@test fy_reconst ≈ fy_ref
@test fz_reconst ≈ fz_ref
end
#==
@testset "asdiagonal" begin
R = 2
sites = siteinds("Qubit", R)
sites′ = [Index(2, "Qubit,n′=$n") for n in 1:R]
M = randomMPS(sites)
for which_new in ["left", "right"]
Mnew = Quantics.asdiagonal(M, sites′; tag="n", which_new=which_new)
M_reconst = reshape(Array(reduce(*, M), reverse(sites)), 2^R)
Mnew_reconst = reshape(Array(reduce(*, Mnew),
vcat(reverse(sites), reverse(sites′))), 2^R, 2^R)
@assert diag(Mnew_reconst) ≈ M_reconst
@assert LinearAlgebra.diagm(M_reconst) ≈ Mnew_reconst
end
end
==#
end
@testitem "transformer_tests.jl/phase_rotation" begin
using Test
import Quantics
using ITensors
using LinearAlgebra
@testset "phase_rotation" begin
nqbit = 3
xvec = collect(0:(2^nqbit - 1))
θ = 0.1
sites = [Index(2, "Qubit,x=$x") for x in 1:nqbit]
_reconst(x) = vec(Array(reduce(*, x), reverse(sites)))
f = randomMPS(sites)
f_vec = _reconst(f)
ref = exp.(im * θ * xvec) .* f_vec
@test ref ≈ _reconst(Quantics.phase_rotation(f, θ; tag="x"))
@test ref ≈ _reconst(Quantics.phase_rotation(f, θ; targetsites=sites))
end
end
@testitem "transformer_tests.jl/shiftaxis" begin
using Test
import Quantics
using ITensors
using LinearAlgebra
@testset "shiftaxis" for R in [3], bc in [1, -1], rev_carrydirec in [true, false]
sitesx = [Index(2, "Qubit, x=$n") for n in 1:R]
sites = rev_carrydirec ? sitesx : reverse(sitesx)
g = randomMPS(sites)
for shift in [0, 1, 2, 2^R - 1]
f = Quantics.shiftaxis(g, shift; bc=bc, tag="x")
f_vec = vec(Array(reduce(*, f), reverse(sitesx)))
g_vec = vec(Array(reduce(*, g), reverse(sitesx)))
f_vec_ref = similar(f_vec)
for i in 1:(2^R)
ishifted = mod1(i + shift, 2^R)
sign = ishifted == i + shift ? 1 : bc
f_vec_ref[i] = g_vec[ishifted] * sign
end
@test f_vec_ref ≈ f_vec
end
end
@testset "shiftaxis2d" for R in [3], bc in [1, -1], rev_carrydirec in [true, false]
sitesx = [Index(2, "Qubit, x=$n") for n in 1:R]
sitesy = [Index(2, "Qubit, y=$n") for n in 1:R]
if rev_carrydirec
sites = collect(Iterators.flatten(zip(sitesx, sitesy)))
else
sites = collect(Iterators.flatten(zip(reverse(sitesx), reverse(sitesy))))
end
g = randomMPS(sites)
for shift in [-4^R + 1, -1, 0, 1, 2^R - 1, 2^R, 2^R + 1, 4^R + 1]
f = Quantics.shiftaxis(g, shift; tag="x", bc=bc)
f_mat = reshape(Array(reduce(*, f), vcat(reverse(sitesx), reverse(sitesy))),
2^R, 2^R)
g_mat = reshape(Array(reduce(*, g), vcat(reverse(sitesx), reverse(sitesy))),
2^R, 2^R)
f_mat_ref = similar(f_mat)
for i in 1:(2^R)
nbc, ishifted = divrem(i + shift - 1, 2^R, RoundDown)
ishifted += 1
f_mat_ref[i, :] = g_mat[ishifted, :] * (bc^nbc)
end
@test f_mat_ref ≈ f_mat
end
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | code | 7763 | @testitem "util.jl" begin
using Test
import Quantics
using ITensors
@testset "_replace_mpo_siteinds!" begin
nbit = 3
sites = siteinds("Qubit", nbit)
M = MPO(ComplexF64, sites, ["Y" for n in 1:nbit])
sites2 = [Index(2, "n=$n") for n in 1:nbit]
Quantics._replace_mpo_siteinds!(M, sites, sites2)
@test all([!hasind(M[n], sites[n]) for n in 1:nbit])
@test all([!hasind(M[n], sites[n]') for n in 1:nbit])
@test all([hasind(M[n], sites2[n]) for n in 1:nbit])
@test all([hasind(M[n], sites2[n]') for n in 1:nbit])
end
#==
@testset "combinesiteinds" begin
# [s1, (s2,s3), (s4,s5), s6]
nbit = 6
sites = siteinds("Qubit", nbit)
csites = [Index(4, "csite=$s") for s in 1:2]
M = randomMPS(sites; linkdims=2)
Mc = Quantics.combinesiteinds(M, csites; targetsites=sites[2:5])
@test length(Mc) == 4
@test all(dim.(siteinds(Mc)) .== [2, 4, 4, 2])
end
@testset "splitsiteind (deprecated)" for nbit in [4, 6]
sites = siteinds("Qubit", nbit)
csites = [Index(4, "csite=$s") for s in 1:(nbit ÷ 2)]
D = 3
mps = randomMPS(csites; linkdims=D)
mps_split = Quantics.splitsiteind(mps, sites)
@test vec(Array(reduce(*, mps_split), sites)) ≈ vec(Array(reduce(*, mps), csites))
mps_reconst = Quantics.combinesiteinds(mps_split, csites)
@test vec(Array(reduce(*, mps_reconst), csites)) ≈
vec(Array(reduce(*, mps), csites))
end
==#
@testset "unfuse_siteinds" for nsites in [2, 4], R in [2, 3]
sites = [Index(2^R, "csite=$s") for s in 1:nsites]
bonddim = 3
mps = randomMPS(sites; linkdims=bonddim)
newsites = [[Index(2, "n=$n,m=$m") for m in 1:R] for n in 1:nsites]
mps_split = Quantics.unfuse_siteinds(mps, sites, newsites)
newsites_flatten = collect(Iterators.flatten(newsites))
@test newsites_flatten == siteinds(mps_split)
@test vec(Array(reduce(*, mps_split), newsites_flatten)) ≈
vec(Array(reduce(*, mps), sites))
end
@testset "split_tensor" begin
nsite = 6
sites = [Index(2, "Qubit, site=$n") for n in 1:nsite]
tensor = randomITensor(sites)
tensors = Quantics.split_tensor(tensor, [sites[1:2], sites[3:4], sites[5:6]])
@test tensor ≈ reduce(*, tensors)
end
@testset "split_tensor2" begin
nsite = 8
sites = [Index(2, "Qubit, site=$n") for n in 1:nsite]
tensor = randomITensor(sites)
tensors = Quantics.split_tensor(tensor, [sites[1:3], sites[4:5], sites[6:8]])
@test length(inds(tensors[1])) == 4
@test length(inds(tensors[2])) == 4
@test length(inds(tensors[3])) == 4
@test tensor ≈ reduce(*, tensors)
end
@testset "matchsiteinds_mps" begin
N = 2
physdim = 2
sites = [Index(physdim, "n=$n") for n in 1:(2N)]
sites_sub = sites[1:2:end]
M = randomMPS(sites_sub) + randomMPS(sites_sub)
M_ext = Quantics.matchsiteinds(M, sites)
tensor = Array(reduce(*, M), sites_sub)
tensor_reconst = zeros(Float64, fill(physdim, 2N)...)
tensor_reconst .= reshape(tensor, size(tensor)..., fill(1, N)...)
tensor2 = Array(reduce(*, M_ext), sites_sub, sites[2:2:end])
@test tensor2 ≈ tensor_reconst
end
@testset "matchsiteinds_mpo" begin
N = 2
physdim = 2
sites = [Index(physdim, "n=$n") for n in 1:(2N)]
sites_A = sites[1:2:end]
sites_B = sites[2:2:end]
M = randomMPO(sites_A) + randomMPO(sites_A)
M_ext = Quantics.matchsiteinds(M, sites)
tensor_ref = reduce(*, M) * reduce(*, [delta(s, s') for s in sites_B])
tensor_reconst = reduce(*, M_ext)
@test tensor_ref ≈ tensor_reconst
end
@testset "matchsiteinds_mpo2" begin
N = 2
physdim = 2
sites = [Index(physdim, "n=$n") for n in 1:(3N)]
sites_A = sites[1:3:end]
sites_B = sites[2:3:end]
sites_C = sites[3:3:end]
sites_BC = vcat(sites_B, sites_C)
M = randomMPO(sites_A) + randomMPO(sites_A)
M_ext = Quantics.matchsiteinds(M, sites)
tensor_ref = reduce(*, M) * reduce(*, [delta(s, s') for s in sites_BC])
tensor_reconst = reduce(*, M_ext)
@test tensor_ref ≈ tensor_reconst
end
@testset "combinsite" begin
nrepeat = 3
N = 3 * nrepeat
sites = siteinds("Qubit", N)
M = MPO(randomMPS(sites))
sites1 = sites[1:3:end]
sites2 = sites[2:3:end]
sites3 = sites[3:3:end]
for n in 1:nrepeat
M = Quantics.combinesites(M, sites1[n], sites2[n])
end
flag = true
for n in 1:nrepeat
flag = flag && hasinds(M[2 * n - 1], sites1[n], sites2[n])
flag = flag && hasind(M[2 * n], sites3[n])
end
@test flag
end
@testset "_directprod" begin
sites1 = siteinds("Qubit", 2)
sites2 = siteinds("Qubit", 2)
M1 = randomMPS(sites1)
M2 = randomMPS(sites2)
M12 = Quantics._directprod(M1, M2)
M1_reconst = Array(reduce(*, M1), sites1)
M2_reconst = Array(reduce(*, M2), sites2)
M12_reconst = Array(reduce(*, M12), vcat(sites1, sites2))
M12_ref = reshape(reshape(M1_reconst, 2^2, 1) * reshape(M2_reconst, 1, 2^2), 2, 2,
2, 2)
@test M12_reconst ≈ M12_ref
end
@testset "rearrange_siteinds (xy)" begin
L = 5
sitesx = [Index(2, "x=$n") for n in 1:L]
sitesy = [Index(2, "y=$n") for n in 1:L]
sitesxy = collect(Iterators.flatten(zip(sitesx, sitesy)))
Ψ = random_mps(sitesxy)
sitesxy_fused = [[x, y] for (x, y) in zip(sitesx, sitesy)]
Ψ_fused = Quantics.rearrange_siteinds(Ψ, sitesxy_fused)
@test prod(Ψ) ≈ prod(Ψ_fused) # We reconstruct a full tensor, do not use it for large L
sitesxy_fused_ = siteinds(MPO(collect(Ψ_fused)))
for (x, y) in zip(sitesxy_fused, sitesxy_fused_)
@test Set(x) == Set(y)
end
Ψ_reconst = Quantics.rearrange_siteinds(Ψ_fused, [[x] for x in sitesxy])
@test Ψ ≈ Ψ_reconst
end
@testset "rearrange_siteinds (xyz)" begin
L = 4
sitesx = [Index(2, "x=$n") for n in 1:L]
sitesy = [Index(2, "y=$n") for n in 1:L]
sitesz = [Index(2, "z=$n") for n in 1:L]
sitesxyz = collect(Iterators.flatten(zip(sitesx, sitesy, sitesz)))
Ψ = random_mps(sitesxyz)
sitesxyz_fused = Vector{Index{Int}}[]
for i in 1:L
push!(sitesxyz_fused, [sitesx[i], sitesy[i]])
push!(sitesxyz_fused, [sitesz[i]])
end
Ψ_fused = Quantics.rearrange_siteinds(Ψ, sitesxyz_fused)
@test prod(Ψ) ≈ prod(Ψ_fused)
sitesxyz_fused_ = siteinds(MPO(collect(Ψ_fused)))
for (x, y) in zip(sitesxyz_fused, sitesxyz_fused_)
@test Set(x) == Set(y)
end
Ψ_reconst = Quantics.rearrange_siteinds(Ψ_fused, [[x] for x in sitesxyz])
@test Ψ ≈ Ψ_reconst
end
@testset "makesitediagonal" begin
L = 2
sitesx = [Index(2, "x=$n") for n in 1:L]
Ψ = random_mps(sitesx)
M = Quantics.makesitediagonal(Ψ, "x")
Ψ_recost = Array(prod(Ψ), sitesx...)
M_recost = Array(prod(M), prime.(sitesx)..., sitesx...)
for i in 1:2, i2 in 1:2, j in 1:2, j2 in 1:2
if i != i2 || j != j2
@test M_recost[i, j, i2, j2] ≈ 0.0
else
@test M_recost[i, j, i2, j2] ≈ Ψ_recost[i, j]
end
end
end
end
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | docs | 702 | # Quantics
[](https://tensor4all.github.io/Quantics.jl/dev)
[](https://github.com/tensor4all/Quantics.jl/actions/workflows/CI.yml)
This library provides a high-level interface to manipulate quantics tensor train (QTT) format in Julia such as Fourier transform, convolution, and matrix-vector multiplication.
This library is based on `ITensors.jl`.
## Installation
The following will install `Quantics.jl`:
```julia
julia> using Pkg; Pkg.add("Quantics.jl")
```
## Usage
Please refer to the [documentation](https://tensor4all.github.io/Quantics.jl/) for usage. | Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.3.8 | b4e7717ed2a5e14f77f45afa972553079fcefc6b | docs | 182 | ```@meta
CurrentModule = Quantics
```
# Quantics
Documentation for [Quantics](https://gitlab.com/tensors4fields/Quantics.jl).
```@index
```
```@autodocs
Modules = [Quantics]
```
| Quantics | https://github.com/tensor4all/Quantics.jl.git |
|
[
"MIT"
] | 0.2.2 | b38a2d112a969af2c6fe4c3fb3e9314705931a8f | code | 3650 | # Inspired by the Mods.jl package
module Modulos
import Base: ==, +, -, *, inv, /, ^, hash, show, unsigned, Bool
import Base.Checked: mul_with_overflow
export Modulo
"""
`Modulo{p,T}(n)` creates a modular number in mod `p` with value `n%p` represented
by the integer type `T`.
"""
struct Modulo{p,T<:Integer} <: Real
value::T
function Modulo{p,T}(n::Integer) where {p,T}
@assert p > 0 # This check is elided at runtime since p is a compile-time constant
return new{p,T}(mod(n, p))
end
end
(::Type{T})(x::Modulo) where {T<:Integer} = T(x.value)
Bool(x::Modulo) = Bool(x.value) # disambiguation
function hash(x::Modulo{p}, h::UInt64=UInt64(0)) where p
hash(Integer(x), hash(p, h))
end
==(x::Modulo{p}, y::Modulo{p}) where {p} = Integer(x) == Integer(y)
@inline function large_widen(::Modulo{p,T1}, ::Modulo{p,T2}) where {p,T1,T2}
T = promote_type(T1,T2)
if T1 != T2
tmin = typemin(T)
tmax = typemax(T)
if !(tmin <= typemin(T1) && tmin <= typemin(T2) &&
tmax >= typemax(T1) && tmax >= typemax(T2))
T = widen(T)
end
end
return T
end
function +(x::Modulo{p,T1}, y::Modulo{p,T2}) where {p,T1,T2}
T = large_widen(x, y)
# Next are some fast-paths if p is small enough.
# Note that the checks are elided at runtime since p and T are compile-time constants
if p < typemax(T) ÷ 2
Modulo{p,T}((Integer(x) % T) + (Integer(y) % T))
elseif p < typemax(unsigned(T)) ÷ 2
U = unsigned(T)
Modulo{p,T}((Integer(x) % U) + (Integer(y) % U))
else
V = widen(T)
Modulo{p,T}((Integer(x) % V) + (Integer(y) % V))
end
end
function -(x::Modulo{p,T}) where {p,T<:Signed}
Modulo{p,T}(-Integer(x))
end
function -(x::Modulo{p,T}) where {p,T<:Unsigned}
U = signed(T)
y = Integer(x)
y > (typemax(U) % T) ? Modulo{p,T}(-(y % widen(U))) : Modulo{p,T}(-signed(y))
end
-(x::Modulo, y::Modulo) = x + (-y)
function *(x::Modulo{p,T1}, y::Modulo{p,T2}) where {p,T1,T2}
T = large_widen(x, y)
r, flag = mul_with_overflow((Integer(x) % T), (Integer(y) % T))
flag ? Modulo{p,T}(widemul(Integer(x), Integer(y))) : Modulo{p,T}(r)
end
@noinline __throw_notinvertible(x) = error(x, " is not invertible")
inv(x::Modulo{1}) = __throw_notinvertible(x)
function inv(x::Modulo{p,T}) where {p,T}
g, v = gcdx(Integer(x), p) # disregard the third value, corresponding to the Bézout coefficient for p
g == 1 || __throw_notinvertible(x)
return Modulo{p,T}(v)
end
function /(x::Modulo{p}, y::Modulo{p}) where {p}
return x * inv(y)
end
function ^(x::Modulo{p,T}, k::Integer) where {p,T}
if k>0
return Modulo{p,T}(powermod(Integer(x), k, p))
end
if k==0
return one(Modulo{p})
end
Modulo{p,T}(powermod(Integer(inv(x)), -k, p))
end
+(x::Modulo{p,T}, k::Integer) where {p,T} = x + Modulo{p,T}(k)
+(k::Integer, x::Modulo) = x + k
-(x::Modulo, k::Integer) = x + (-k)
-(k::Integer, x::Modulo) = (-x) + k
*(x::Modulo{p,T}, k::Integer) where {p,T} = x * Modulo{p,T}(k)
*(k::Integer, x::Modulo) = x * k
/(x::Modulo{p,T}, k::Integer) where {p,T} = x / Modulo{p,T}(k)
/(k::Integer, x::Modulo{p,T}) where {p,T} = Modulo{p,T}(k) / x
function ==(x::Modulo{p,T1}, k::T2) where {p,T1,T2<:Integer}
T = promote_type(T1,T2)
T(x) == T(mod(k, p))
end
==(k::Integer, x::Modulo) = x == k
function show(io::IO, x::Modulo{p,T}) where {p,T}
verbose = get(io, :typeinfo, Any) != Modulo{p,T}
if verbose
print(io, Modulo{p,T}, '(')
end
print(io, x.value)
if verbose
print(io, ')')
end
end
end # end of module Modulos
| PeriodicGraphEquilibriumPlacement | https://github.com/Liozou/PeriodicGraphEquilibriumPlacement.jl.git |
|
[
"MIT"
] | 0.2.2 | b38a2d112a969af2c6fe4c3fb3e9314705931a8f | code | 225 | module PeriodicGraphEquilibriumPlacement
export equilibrium, dixon_solve, rational_solve
using PeriodicGraphs, SparseArrays
include("Modulos.jl")
include("solver.jl")
include("embedding.jl")
include("precompile.jl")
end
| PeriodicGraphEquilibriumPlacement | https://github.com/Liozou/PeriodicGraphEquilibriumPlacement.jl.git |
|
[
"MIT"
] | 0.2.2 | b38a2d112a969af2c6fe4c3fb3e9314705931a8f | code | 1328 | # Main functions
using PeriodicGraphs, Graphs
using StaticArrays: SizedVector
using LinearAlgebra: Adjoint
_catzeros(::Val{N}, Z::Adjoint{T}) where {T,N} = hcat(zeros(T, N), Z)
"""
equilibrium(g::PeriodicGraph)
Return an equilibrium placement for the vertices of the graph, defined as a list
of positions such that each vertex is at the barycentre of its neighbors.
The returned equilibrium placement is such that the first vertex of the graph
is at the origin of the space.
"""
function equilibrium(g::PeriodicGraph{N}) where N
n = nv(g)
iszero(n) && return Matrix{Rational{Int64}}(undef, N, 0)
isone(n) && return zeros(Rational{Int64}, N, 1)
Y = Matrix{Int}(undef, n, N)
A = spzeros(Int, n, n)
neigh = Vector{Int}(undef, n)
offset = SizedVector{N,Int}(undef)
for i in 1:n
neigh .= 0
offset .= 0
count = 0
for k in neighbors(g, i)
k.v == i && continue
count += 1
neigh[k.v] += 1
offset .-= k.ofs
end
Y[i,:] .= offset
A[i,:] .= neigh
A[i,i] = -count
end
Z = dixon_solve(Val(N), A[2:end,2:end], Y[2:end,:])
isempty(Z) && error("Singular exception while equilibrating. Is the graph connected and of the given dimensionality?")
return _catzeros(Val(N), Z')
end
| PeriodicGraphEquilibriumPlacement | https://github.com/Liozou/PeriodicGraphEquilibriumPlacement.jl.git |
|
[
"MIT"
] | 0.2.2 | b38a2d112a969af2c6fe4c3fb3e9314705931a8f | code | 1686 | using PeriodicGraphEquilibriumPlacement, PeriodicGraphs, LinearAlgebra, SparseArrays
using PrecompileTools
@setup_workload begin
pcu = PeriodicGraph("3 1 1 0 0 1 1 1 0 1 0 1 1 1 0 0");
afy = PeriodicGraph("3 1 2 0 0 0 1 3 0 0 0 1 4 0 0 0 1 5 0 0 0 2 6 0 0 0 2 7 0 0 0 2 8 0 0 0 3 7 0 0 0 3 9 0 0 0 3 10 0 0 0 4 8 0 0 0 4 9 0 0 0 4 11 0 0 0 5 7 0 1 0 5 8 0 1 0 5 9 0 1 0 6 12 0 0 0 6 13 0 0 0 6 14 0 0 0 7 14 0 0 0 8 15 0 0 0 9 12 -1 0 1 10 12 -1 0 1 10 13 -1 0 1 10 15 0 0 1 11 13 -1 0 0 11 14 -1 0 0 11 15 0 0 0 12 16 0 0 0 13 16 0 1 0 14 16 0 0 0 15 16 -1 0 0")
A = sparse([208 72 887 687 946 263 905 943 131 183 256 606 613 854 914; 582 279 104 638 1 272 130 214 910 813 376 376 202 362 384; 786 526 26 700 84 417 430 253 894 41 895 207 620 918 163; 753 98 421 556 839 665 861 678 614 245 548 186 831 774 642; 834 257 952 786 485 529 66 833 619 258 886 901 488 55 87; 917 536 333 316 295 528 645 777 236 4 247 641 411 101 262; 394 87 654 584 354 858 361 570 990 326 279 348 984 623 251; 774 33 215 61 577 492 634 769 755 577 176 989 964 379 104; 176 21 886 253 198 886 545 136 958 175 311 646 954 730 927; 654 216 757 545 975 391 56 480 258 861 639 126 53 295 739; 29 619 956 175 693 567 734 415 645 704 818 291 678 557 973; 964 112 555 991 366 297 105 482 26 848 221 687 50 53 119; 155 938 591 60 807 704 157 929 289 128 846 971 31 658 530; 736 711 941 890 816 473 171 60 299 167 434 819 582 913 856; 668 14 20 336 336 823 651 164 468 737 181 828 192 93 58])
Y = [15*j + i for i in 1:15, j in -1:1]
v = Val(3)
@compile_workload begin
equilibrium(pcu)
equilibrium(afy)
dixon_solve(v, A, Y)
rational_solve(v, A, Y)
end
end
| PeriodicGraphEquilibriumPlacement | https://github.com/Liozou/PeriodicGraphEquilibriumPlacement.jl.git |
|
[
"MIT"
] | 0.2.2 | b38a2d112a969af2c6fe4c3fb3e9314705931a8f | code | 17971 | ## Specialized solver for sparse symmetric integer linear systems with exact rational solution
using .Modulos
import Base.GMP: MPZ
using Base: OneTo
using LinearAlgebra: BlasInt, checknonsingular, LU, tril!, triu!, issuccess, norm
using SparseArrays
using SparseArrays: getcolptr
# using BigRationals
function compat_checknonsingular(i)
@static if VERSION < v"1.7-"
checknonsingular(i, Val(false))
else
checknonsingular(i, NoPivot())
end
end
function compat_lu(::Type{Tf}, B, maxvec, info) where Tf
@static if VERSION < v"1.8-"
LU{Tf,SparseMatrixCSC{Tf,Int}}(dropzeros!(B), Vector{BlasInt}(1:maxvec), convert(BlasInt, info))
else
LU{Tf,SparseMatrixCSC{Tf,Int},OneTo{Int}}(Tf.(B), 1:maxvec, info)
end
end
function compat_lu_convert(::Type{Tf}, B, maxvec, info) where Tf
@static if VERSION < v"1.8-"
LU{Tf,SparseMatrixCSC{Tf,Int}}(Tf.(dropzeros!(B)), Vector{BlasInt}(1:maxvec), convert(BlasInt, info))
else
LU{Tf,SparseMatrixCSC{Tf,Int},OneTo{Int}}(Tf.(B), 1:maxvec, info)
end
end
function rational_lu!(B::SparseMatrixCSC, col_offset::Vector{Int}, check=true)
Tf = eltype(B)
m, n = size(B)
minmn = min(m, n)
info = 0
@inbounds begin
for k in 1:minmn
ipiv = getcolptr(B)[k] + col_offset[k]
piv = nonzeros(B)[ipiv]
if iszero(piv)
check && compat_checknonsingular(k-1) # TODO update with Pivot
return compat_lu(Tf, B, minmn, k-1)
end
Bkkinv = inv(piv)
nzB = nonzeros(B)
@simd ivdep for i in ipiv+1:getcolptr(B)[k+1]-1
nzB[i] *= Bkkinv
end
for j in k+1:n
r1 = getcolptr(B)[j]
r2 = getcolptr(B)[j+1]-1
r = searchsortedfirst(rowvals(B), k, r1, r2, Base.Forward)
((r > r2) || (rowvals(B)[r] != k)) && continue
Bkj = nonzeros(B)[r]
for i in ipiv+1:getcolptr(B)[k+1]-1
Bik = nonzeros(B)[i]
l = i - ipiv
while rowvals(B)[l+r] < rowvals(B)[i]
r += 1
end
nonzeros(B)[l+r] -= Bik * Bkj
end
end
end
end
check && compat_checknonsingular(info)
return compat_lu(Tf, B, minmn, info)
end
@static if VERSION < v"1.10-"
const libgmp = Sys.iswindows() ? "libgmp-10.dll" : Sys.isapple() ? "@rpath/libgmp.10.dylib" : "libgmp.so.10"
else
const libgmp = Base.GMP.libgmp
end
@static if VERSION < v"1.9-"
# Base.GMP.MPQ.mul!, div! and sub! introduced in v1.9
const MPQ = Base.GMP.MPQ
function set_si!(z::Rational{BigInt}, a, b)
zq = MPQ._MPQ(z)
ccall((:__gmpq_set_si, libgmp), Cvoid, (MPQ.mpq_t, Clong, Culong), zq, a, b)
return MPQ.sync_rational!(zq)
end
function mpq_sub!(x::Rational{BigInt}, y::Rational{BigInt})
if iszero(x.den) || iszero(y.den)
if iszero(x.den) && iszero(y.den) && isneg(x.num) == isneg(y.num)
throw(DivideError())
end
iszero(x.den) && return x
return set_si!(x, flipsign(-1, y.num), 0)
end
xq = MPQ._MPQ(x)
ccall((:__gmpq_sub, libgmp), Cvoid,
(MPQ.mpq_t,MPQ.mpq_t,MPQ.mpq_t), xq, xq, MPQ._MPQ(y))
return MPQ.sync_rational!(xq)
end
function mpq_mul!(z::Rational{BigInt}, x::Rational{BigInt}, y::Rational{BigInt})
if iszero(x.den) || iszero(y.den)
if iszero(x.num) || iszero(y.num)
throw(DivideError())
end
return set_si!(z, ifelse(xor(isneg(x.num), isneg(y.num)), -1, 1), 0)
end
zq = MPQ._MPQ(z)
ccall((:__gmpq_mul, libgmp), Cvoid,
(MPQ.mpq_t,MPQ.mpq_t,MPQ.mpq_t), zq, MPQ._MPQ(x), MPQ._MPQ(y))
return MPQ.sync_rational!(zq)
end
function mpq_div!(x::Rational{BigInt}, y::Rational{BigInt})
if iszero(x.den)
if iszero(y.den)
throw(DivideError())
end
isneg(y.num) || return x
return set_si!(x, flipsign(-1, x.num), 0)
elseif iszero(y.den)
return set_si!(x, 0, 1)
elseif iszero(y.num)
if iszero(x.num)
throw(DivideError())
end
return set_si!(x, flipsign(1, x.num), 0)
end
xq = Base.GMP.MPQ._MPQ(x)
ccall((:__gmpq_div, libgmp), Cvoid,
(Base.GMP.MPQ.mpq_t,Base.GMP.MPQ.mpq_t,Base.GMP.MPQ.mpq_t), xq, xq, Base.GMP.MPQ._MPQ(y))
return Base.GMP.MPQ.sync_rational!(xq)
end
else
const mpq_div! = Base.GMP.MPQ.div!
const mpq_mul! = Base.GMP.MPQ.mul!
const mpq_sub! = Base.GMP.MPQ.sub!
end
# function lu!(B::SparseMatrixCSC{<:Rational}, ::Val{Pivot} = Val(false);
# col_offset, check::Bool = true) where Pivot
function rational_lu!(B::SparseMatrixCSC{Rational{BigInt}}, col_offset::Vector{Int}, check::Bool=true)
Tf = Rational{BigInt}
m, n = size(B)
minmn = min(m, n)
tmp = Rational{BigInt}(0)
@inbounds begin
for k in 1:minmn
ipiv = getcolptr(B)[k] + col_offset[k]
piv = nonzeros(B)[ipiv]
if iszero(piv)
check && compat_checknonsingular(k-1) # TODO update with Pivot
return compat_lu_convert(Tf, B, minmn, k-1)
end
for i in ipiv+1:getcolptr(B)[k+1]-1
mpq_div!(nonzeros(B)[i], piv)
# BigRationals.MPQ.div!(nonzeros(B)[i], piv)
end
for j in k+1:n
r1 = getcolptr(B)[j]
r2 = getcolptr(B)[j+1]-1
r = searchsortedfirst(rowvals(B), k, r1, r2, Base.Forward)
((r > r2) || (rowvals(B)[r] != k)) && continue
Bkj = nonzeros(B)[r]
for i in ipiv+1:getcolptr(B)[k+1]-1
Bik = nonzeros(B)[i]
l = i - ipiv
while rowvals(B)[l+r] < rowvals(B)[i]
r += 1
end
mpq_mul!(tmp, Bik, Bkj)
mpq_sub!(nonzeros(B)[l+r], tmp)
# BigRationals.MPQ.mul!(tmp, Bik, Bkj)
# BigRationals.MPQ.sub!(nonzeros(B)[l+r], tmp)
end
end
end
end
info = something(findfirst(i -> iszero(B[i,i]), Base.OneTo(minmn)), 0)
check && compat_checknonsingular(info)
return compat_lu_convert(Tf, B, minmn, info)
end
# function lu(A::SparseMatrixCSC{<:Rational}, pivot::Union{Val{false}, Val{true}} = Val(false); check::Bool = true)
function rational_lu(A::SparseMatrixCSC, check::Bool=true, ::Type{Ti}=Rational{BigInt}) where {Ti}
Tf = Ti
# Tf = Ti == BigRational ? Rational{BigInt} : Ti
Base.require_one_based_indexing(A)
_I, _J, _V = findnz(A)
I, J, V = issorted(_J) ? (_I, _J, _V) : begin
_indices = sortperm(_J)
@inbounds (_I[_indices], _J[_indices], _V[_indices])
end
# @inbounds if !issorted(_J)
# indices = sortperm(J)
# I = I[indices]; J = J[indices]; V = V[indices]
# end
isempty(J) && return compat_lu_convert(Tf, A, 0, 0)
m, n = size(A)
minmn = min(m, n)
if J[1] != 1 || I[1] != 1
check && compat_checknonsingular(1) # TODO update with Pivot
# return LU{eltype(A), typeof(A)}(A, collect(1:minmn), convert(BlasInt, 1))
return compat_lu_convert(Tf, A, minmn, 1)
end
col_offset = zeros(Int, minmn) # for each col, index of the pivot element
idx_cols = [[I[i] for i in getcolptr(A)[col+1]-1:-1:getcolptr(A)[col]] for col in 1:minmn]
# For each column, indices of the non-zeros elements
in_idx_colscol = falses(n)
for col in 2:minmn
sort!(idx_cols[col-1]; rev=true)
# All idx_cols[x] are sorted by decreasing order for x < col
# @show idx_cols[col]
idx_colscol = idx_cols[col]
in_idx_colscol[idx_colscol] .= true
for row_j in idx_colscol
row_j >= col && continue
col_offset[col] += 1
# @show idx_cols[row_j]
idx_colsj = idx_cols[row_j]
sizcol = length(idx_colscol)
for row_i in idx_colsj
if row_i ≤ row_j
break # Because the row_i are sorted in decreasing order
end
if !in_idx_colscol[row_i]
push!(idx_colscol, row_i)
in_idx_colscol[row_i] = true
end
end
countadd = length(idx_colscol) - sizcol
if countadd > 0
siz = length(I)
resize!(I, siz + countadd)
resize!(J, siz + countadd)
resize!(V, siz + countadd)
for i in 1:countadd
row_i = idx_colscol[sizcol+i]
_idx = siz + i
J[_idx] = col
I[_idx] = row_i
V[_idx] = 0
end
end
end
in_idx_colscol[idx_colscol] .= false
end
B = sparse(I, J, Ti.(V)) # TODO update with Pivot
rational_lu!(B, col_offset, check)
end
function forward_substitution!(L::SparseMatrixCSC, b)
_, n = size(L)
_, m = size(b)
@inbounds for col in 1:n
k = getcolptr(L)[col]
if rowvals(L)[k] != col && col != 0
return false
end
invnzLk = inv(nonzeros(L)[k])
x = invnzLk .* b[col,:]
b[col,:] .= x
for i in (k+1):getcolptr(L)[col+1]-1
nzLi = nonzeros(L)[i]
rvLi = rowvals(L)[i]
@simd ivdep for j in 1:m
b[rvLi,j] -= nzLi*x[j]
end
end
end
true
end
function backward_substitution!(U::SparseMatrixCSC, b)
_, n = size(U)
_, m = size(b)
@inbounds for col in n:-1:1
k = getcolptr(U)[col+1]-1
if rowvals(U)[k] != col && col != 0
return false
end
invnzUk = inv(nonzeros(U)[k])
x = invnzUk .* b[col,:]
b[col,:] .= x
for i in getcolptr(U)[col]:(k-1)
nzUi = nonzeros(U)[i]
rvUi = rowvals(U)[i]
@simd ivdep for j in 1:m
b[rvUi,j] -= nzUi*x[j]
end
end
end
true
end
function linsolve!(F::LU, B::Matrix)
TFB = typeof(oneunit(eltype(B)) / oneunit(eltype(F)))
BB = similar(B, TFB, size(B))
copyto!(BB, B)
m, n = size(F)
minmn = min(m,n)
L = tril!(getfield(F, :factors)[1:m, 1:minmn])
for i = 1:minmn; L[i,i] = 1; end
forward_substitution!(L, BB) || return BB, false
x = triu!(getfield(F, :factors)[1:minmn, 1:n])
backward_substitution!(x, BB) || return BB, false
return BB, true
end
"""
rational_solve(::Val{N}, A::SparseMatrixCSC{Int,Int}, Y::Matrix{Int}) where N
Fallback solver for [`dixon_solve`](@ref) which performs an LU decomposition followed by
forward and backward substitutions. Return an empty matrix if `A` is not invertible.
In general, it is slower than [`dixon_solve`](@ref).
!!! warning
`A` must be square and `N` must be equal to `size(Y)[2]` or the function may fail,
error, or cause a silent corruption without notice.
"""
function rational_solve(::Val{N}, A::SparseMatrixCSC{Int,Int}, Y::Matrix{Int}) where N
B = rational_lu(A, false)
issuccess(B) || return Matrix{Rational{Int128}}(undef, 0, 0)
Z, check = linsolve!(B, Rational{BigInt}.(Y))
check || error("Singular exception on substitution. Please report this error by opening an issue.")
for x in Z
if numerator(x) > typemax(Int128) || numerator(x) < typemin(Int128) ||
denominator(x) > typemax(Int128) || denominator(x) < typemin(Int128)
return Z
end
end
return Rational{Int128}.(Z)
# Rational{Int64} is not enough for tep for instance.
end
function copyuntil(j, oldZ, ::Type{T}) where T
Z = similar(oldZ, T)
for i in eachindex(Z)
i == j && return Z
Z[i] = oldZ[i]
end
error("Invalid failure of _inner_dixon_p!. Please report this error by opening an issue.")
return Z # Does not matter but just in case for type stability
end
function _inner_dixon_p!(indices::Vector{Int}, Z::Matrix{Rational{T}}, h::BigInt,
x̄::Matrix{BigInt}, sqh::BigInt, tmp::BigInt) where T
while !isempty(indices)
j = pop!(indices)
ua = MPZ.set(h)
ub = deepcopy(@inbounds x̄[j])
va = Int128(0)
vb = Int128(1)
k = 0
while ub >= sqh
k += 1
# cpua = deepcopy(ua)
# cpub = deepcopy(ub)
MPZ.tdiv_qr!(tmp, ua, ua, ub)
ua, ub = ub, ua
# @assert tmp == cpua ÷ cpub
# @assert ua == cpub
# @assert ub == cpua - tmp * cpub
# cpuc = deepcopy(va)
if typemin(Clong) < vb < typemax(Clong)
MPZ.mul_si!(tmp, vb % Clong)
else
tmp *= vb
end
flag = signbit(va)
va = abs(va)
if va < typemax(Culong)
if flag
MPZ.sub_ui!(tmp, va)
else
MPZ.add_ui!(tmp, va)
end
va, vb = vb, Int128(tmp)
else
va, vb = vb, va + tmp
end
#= or replace all of the above since if typemin(Clong) < ... by
MPZ.mul!(tmp, vb)
MPZ.add!(tmp, va)
va, vb, tmp = vb, tmp, va
=#
# @assert vb == cpuc + tmp * va
end
uv::Tuple{T,T} = if T === BigInt
Base.divgcd(ub, vb)
else
ud, vd = Base.divgcd(ub, vb)
m = typemin(T)
M = typemax(T)
if !(m < ud < M && m < vd < M)
push!(indices, j)
return false
end
(ud % T, vd % T)
end
@inbounds Z[j] = (-2*isodd(k)+1) * Base.checked_den(uv[1], uv[2])
# @assert mod((-1)^isodd(k) * ub, h) == mod(vb * x̄[j], h)
end
return true
end
function dixon_p(::Val{N}, A::SparseMatrixCSC{Int,Int}, C::LU{Modulo{p,Int32}}, Y::Matrix{Int}) where {N,p}
λs = [norm(x) for x in eachcol(A)]
append!(λs, norm(x) for x in eachcol(Y))
partialsort!(λs, N)
for _ in 1:N
popfirst!(λs)
end
δ::BigFloat = prod(BigFloat, λs; init=one(BigFloat))
m = ceil(Int, 2*log(δ / (MathConstants.φ - 1))/log(p))
# @assert m ≥ 1
B = copy(Y)
Z::Union{Matrix{Rational{Int64}},Matrix{Rational{Int128}},Matrix{Rational{BigInt}}} = similar(Y, Rational{Int64})
BB, check = linsolve!(C, B)
check || return Z, false
x̄ = BigInt.(BB)
X = copy(x̄)
# @assert A * Modulo{p,Int32}.(X) == B
h = one(BigInt) # = p^i
tmp = BigInt()
for _ in 1:m-1
MPZ.mul_si!(h, p)
B .= (B .- A*Integer.(X)) .÷ p
BB2, check2 = linsolve!(C, B)
check2 || return Z, false
X .= Integer.(BB2)
# @assert A * Modulo{p,Int32}.(X) == B
@inbounds for j in eachindex(x̄)
MPZ.mul!(tmp, X[j], h)
MPZ.add!(x̄[j], tmp)
end
end
MPZ.mul_si!(h, p) # h = p^m
# @assert mod.(A * x̄, h) == mod.(Y, h)
sqh = MPZ.sqrt(h) # h = p^{m/2}
indices = collect(reverse(eachindex(Z)))
success = _inner_dixon_p!(indices, Z, h, x̄, sqh, tmp)
if !success
Z = copyuntil(first(indices), Z, Rational{Int128})
success = _inner_dixon_p!(indices, Z, h, x̄, sqh, tmp)
if !success
Z = copyuntil(first(indices), Z, Rational{BigInt})
success = _inner_dixon_p!(indices, Z, h, x̄, sqh, tmp)
# @assert success
end
end
# @assert eltype(Y).(A * big.(Z)) == Y
return Z, true
end
@static if VERSION < v"1.8-"
const typeofB = Union{
LU{Modulo{2147483647,Int32},SparseMatrixCSC{Modulo{2147483647,Int32},Int}},
LU{Modulo{2147483629,Int32},SparseMatrixCSC{Modulo{2147483629,Int32},Int}},
LU{Modulo{2147483587,Int32},SparseMatrixCSC{Modulo{2147483587,Int32},Int}}
}
else
const typeofB = Union{
LU{Modulo{2147483647,Int32},SparseMatrixCSC{Modulo{2147483647,Int32},Int},OneTo{Int}},
LU{Modulo{2147483629,Int32},SparseMatrixCSC{Modulo{2147483629,Int32},Int},OneTo{Int}},
LU{Modulo{2147483587,Int32},SparseMatrixCSC{Modulo{2147483587,Int32},Int},OneTo{Int}}
}
end
function try_modulo(::Val{N}, A, Y, ::Type{Modulo{p,T}}) where {N,p,T}
B::typeofB = rational_lu(A, false, Modulo{p,Int32})
issuccess(B) || Matrix{Rational{Int64}}(undef, 0, 0), false
return dixon_p(Val(N), A, B, Y)
end
"""
dixon_solve(::Val{N}, A::SparseMatrixCSC{Int,Int}, Y::Matrix{Int}) where N
Specialized solver for the linear system `A*X = Y` where `A` is a sparse integer `n×n`
matrix and `Y` is a dense integer `n×N` matrix, using Dixon's method.
Return `X` as either a `Matrix{Rational{Int64}}`, a `Matrix{Rational{Int128}}` or a
`Matrix{Rational{BigInt}}`, whichever smallest type can hold all its values.
Return an empty matrix if `A` is not invertible.
!!! warning
`A` must be square and `N` must be equal to `size(Y)[2]` or the function may fail,
error, or cause a silent corruption without notice.
"""
function dixon_solve(::Val{N}, A::SparseMatrixCSC{Int,Int}, Y::Matrix{Int}) where N
# @show time_ns()
Z, success = try_modulo(Val(N), A, Y, Modulo{2147483647,Int32})
success && return Z
Z, success = try_modulo(Val(N), A, Y, Modulo{2147483629,Int32})
success && return Z
Z, success = try_modulo(Val(N), A, Y, Modulo{2147483587,Int32})
success && return Z
# The probability of this being required is *extremely* low
return rational_solve(Val(N), A, Y)
end
| PeriodicGraphEquilibriumPlacement | https://github.com/Liozou/PeriodicGraphEquilibriumPlacement.jl.git |
|
[
"MIT"
] | 0.2.2 | b38a2d112a969af2c6fe4c3fb3e9314705931a8f | code | 3457 | using PeriodicGraphEquilibriumPlacement
using Graphs, PeriodicGraphs, SparseArrays
using Test, Random, LinearAlgebra
function is_at_mean_position(g::PeriodicGraph{D}, poss, i) where D
neighs = neighbors(g, i)
(@view poss[:,i]) == sum((@view poss[:,v]) .+ o for (v, o) in neighs) .// length(neighs)
end
function all_at_mean_position(g, poss=equilibrium(g))
all(x -> is_at_mean_position(g, poss, x), 1:nv(g))
end
@testset "equilibrium" begin
pcu = PeriodicGraph("3 1 1 0 0 1 1 1 0 1 0 1 1 1 0 0");
@test equilibrium(pcu) == reshape(Rational{Int64}[0//1; 0//1; 0//1], 3, 1)
@test all_at_mean_position(pcu)
dia = PeriodicGraph("3 1 2 0 0 0 1 2 0 0 1 1 2 0 1 0 1 2 1 0 0");
@test all_at_mean_position(dia)
srs = PeriodicGraph("3 1 2 0 0 0 1 3 0 0 0 1 4 0 0 0 2 3 1 0 0 2 4 0 -1 0 3 4 0 0 -1");
@test all_at_mean_position(srs)
afy = PeriodicGraph("3 1 2 0 0 0 1 3 0 0 0 1 4 0 0 0 1 5 0 0 0 2 6 0 0 0 2 7 0 0 0 2 8 0 0 0 3 7 0 0 0 3 9 0 0 0 3 10 0 0 0 4 8 0 0 0 4 9 0 0 0 4 11 0 0 0 5 7 0 1 0 5 8 0 1 0 5 9 0 1 0 6 12 0 0 0 6 13 0 0 0 6 14 0 0 0 7 14 0 0 0 8 15 0 0 0 9 12 -1 0 1 10 12 -1 0 1 10 13 -1 0 1 10 15 0 0 1 11 13 -1 0 0 11 14 -1 0 0 11 15 0 0 0 12 16 0 0 0 13 16 0 1 0 14 16 0 0 0 15 16 -1 0 0")
@test all_at_mean_position(afy)
wrong = PeriodicGraph2D(PeriodicGraph("1 1 2 0 1 3 0 5 2 0 5 3 0 2 3 1"))
@test_throws ErrorException equilibrium(wrong)
end
@testset "dixon_solve and rational_solve" begin
for N in 1:5
for n in 1:5
_A = Int.(rand(Int8, n, n))
A = sparse(Int.(_A) .+ 300*LinearAlgebra.I(n)) # ensure the system is invertible
Y = Int.(rand(Int8, n, N))
result = dixon_solve(Val(N), A, Y)
@test A*result == Y
@test result == rational_solve(Val(N), A, Y)
end
end
A = sparse([208 72 887 687 946 263 905 943 131 183 256 606 613 854 914; 582 279 104 638 1 272 130 214 910 813 376 376 202 362 384; 786 526 26 700 84 417 430 253 894 41 895 207 620 918 163; 753 98 421 556 839 665 861 678 614 245 548 186 831 774 642; 834 257 952 786 485 529 66 833 619 258 886 901 488 55 87; 917 536 333 316 295 528 645 777 236 4 247 641 411 101 262; 394 87 654 584 354 858 361 570 990 326 279 348 984 623 251; 774 33 215 61 577 492 634 769 755 577 176 989 964 379 104; 176 21 886 253 198 886 545 136 958 175 311 646 954 730 927; 654 216 757 545 975 391 56 480 258 861 639 126 53 295 739; 29 619 956 175 693 567 734 415 645 704 818 291 678 557 973; 964 112 555 991 366 297 105 482 26 848 221 687 50 53 119; 155 938 591 60 807 704 157 929 289 128 846 971 31 658 530; 736 711 941 890 816 473 171 60 299 167 434 819 582 913 856; 668 14 20 336 336 823 651 164 468 737 181 828 192 93 58])
Y = [15*j + i for i in 1:15, j in -1:1]
result = dixon_solve(Val(3), A, Y)
@test A*result == Y
@test result == rational_solve(Val(3), A, Y)
end
@testset "dixon_solve edge cases" begin
A = Int.(rand(Int8, 7, 7))
Y = Int.(rand(Int8, 7, 3))
for (i,p) in ((5, 2147483647), (7, 2147483629), (4, 2147483587))
v = zeros(Int, 7)
v[i] = p
A[:,i] = A[i,:] = v
@test A*(dixon_solve(Val(3), sparse(A), Y)) == Y
end
A2 = sparse([1, 2, 4, 1, 2, 4, 1, 2, 4], [1, 1, 1, 2, 2, 2, 4, 4, 4], [-3, 1, 1, 1, -3, 1, 1, 1, -2], 4, 4)
Y2 = [1 1; 0 2; 1 -1; 0 0];
@test isempty(rational_solve(Val(2), A2, Y2))
@test isempty(dixon_solve(Val(2), A2, Y2))
end
| PeriodicGraphEquilibriumPlacement | https://github.com/Liozou/PeriodicGraphEquilibriumPlacement.jl.git |
|
[
"MIT"
] | 0.2.2 | b38a2d112a969af2c6fe4c3fb3e9314705931a8f | docs | 3163 | # PeriodicGraphEquilibriumPlacement
[](https://github.com/Liozou/PeriodicGraphEquilibriumPlacement.jl/actions/workflows/CI.yml?query=branch%3Amain)
[](https://codecov.io/gh/Liozou/PeriodicGraphEquilibriumPlacement.jl)
A Julia package for computing the *equilibrium*, or *barycentric*, placement of vertices
of a periodic graph, as defined by [Olaf Delgado-Friedrichs and Michael O'Keeffe](https://doi.org/10.1107/S0108767303012017).
It is accessible through the `equilibrium` exported function, which returns a matrix of
rational coordinates that can be fed to the [`PeriodicGraphEmbedding`](https://liozou.github.io/PeriodicGraphEmbeddings.jl/dev/types/#PeriodicGraphEmbeddings.PeriodicGraphEmbedding-Union{Tuple{T},%20Tuple{D},%20Tuple{PeriodicGraph{D},%20AbstractMatrix{T},%20Cell}}%20where%20{D,%20T})
or
[`SortedPeriodicGraphEmbedding`](https://liozou.github.io/PeriodicGraphEmbeddings.jl/dev/types/#PeriodicGraphEmbeddings.SortedPeriodicGraphEmbedding-Union{Tuple{T},%20Tuple{D},%20Tuple{PeriodicGraph{D},%20AbstractMatrix{T}%20where%20T,%20Cell}}%20where%20{D,%20T})
methods from [PeriodicGraphEmbeddings.jl](https://github.com/Liozou/PeriodicGraphEmbeddings.jl):
```julia
julia> tbo = PeriodicGraph3D("3 1 2 0 0 0 1 3 0 0 0 1 4 0 0 0 2 5 0 0 0 2 6 0 0 0 2 7 0 0 0 3 6 0 0 1 3 8 0 0 0 3 9 0 0 0 4 6 1 0 0 4 10 0 0 0 4 11 0 0 0 5 12 0 0 0 5 13 0 0 0 7 12 1 1 -1 7 13 0 1 0 8 12 0 0 0 8 14 0 0 0 9 12 1 1 0 9 14 0 1 0 10 13 0 0 0 10 14 0 0 0 11 13 1 1 0 11 14 1 1 -1");
julia> equilibrium(tbo)
3×14 Matrix{Rational{Int64}}:
0//1 -1//6 -1//6 1//3 -1//3 -1//3 0//1 -1//3 0//1 0//1 2//3 -2//3 -1//6 -1//6
0//1 0//1 0//1 0//1 -1//3 0//1 1//3 -1//3 1//3 -1//3 1//3 -1//2 -1//2 -1//2
0//1 -1//6 1//3 -1//6 0//1 -1//3 -1//3 1//3 1//3 0//1 -1//3 1//3 -1//6 1//3
```
The implementation is optimized through a custom solver specialized for the exact
resolution of sparse integer linear system through [Dixon's algorithm](https://doi.org/10.1007/bf01459082).
The solver is directly accessible through the `dixon_solve` function:
```julia
julia> A = sparse([-3 0 2 0; 0 -5 2 3; 2 2 -2 0; 0 3 0 -3]);
julia> Y = [1 1; 0 2; 1 -1; 0 0];
julia> A * dixon_solve(Val(2), A, Y) == Y
true
```
The first argument of `dixon_solve` must be `Val(size(Y)[2])` and the second must be square.
The package also exposes a `rational_solve` function which solves the same systems through
a simpler LU decomposition approach. It serves as fallback to `dixon_solve` when Dixon's
algorithm fails, but can also be used as-is with the same API. Its performance is in
general lower than `dixon_solve`, often significantly so.
See also:
- [PeriodicGraphs.jl](https://github.com/Liozou/PeriodicGraphs.jl) for the
underlying library and the API of the `PeriodicGraph` type.
- [CrystalNets.jl](https://github.com/coudertlab/CrystalNets.jl) for a dependent package
specialized on crystal nets.
| PeriodicGraphEquilibriumPlacement | https://github.com/Liozou/PeriodicGraphEquilibriumPlacement.jl.git |
|
[
"MIT"
] | 0.1.0 | 2870c7c22941912749fa593881903a1cd18057fc | code | 965 | using SmoothInterpolation
using Luxor
height = 500
wide = false
Drawing(wide ? 2 * height : height, height, normpath(@__DIR__, "src/assets/logo.svg"))
origin()
# Distance of dots from the origin
R = 0.4 * height
# Radius of dots
r = 0.05 * height
# Dot coordinates
phi = [(i + 1) * 2π / 3 - π / 2 for i in 1:3]
x_dots = R * cos.(phi)
y_dots = R * sin.(phi)
# Interpolation curves
N = 100
setline(10)
for λ in 0.5:0.25:1.0
itp = SmoothedLinearInterpolation(y_dots, x_dots; λ, extrapolate = true)
x_curve = range(x_dots[1], x_dots[end]; length = N)
y_curve = itp.(x_curve)
points = Point.(x_curve, y_curve)
setcolor(λ .* Luxor.julia_blue)
for i in 1:(N - 1)
line(points[i + 1], points[i], :stroke)
end
end
# The julia colored dots
colors = [Luxor.julia_purple, Luxor.julia_red, Luxor.julia_green]
for (x, y, c) in zip(x_dots, y_dots, colors)
setcolor(c)
circle(Point(x, y), r; action = :fill)
end
finish()
preview()
| SmoothInterpolation | https://github.com/SouthEndMusic/SmoothInterpolation.jl.git |
|
[
"MIT"
] | 0.1.0 | 2870c7c22941912749fa593881903a1cd18057fc | code | 882 | using Documenter, SmoothInterpolation
makedocs(;
sitename = "SmoothInterpolation.jl",
pages = [
"Home" => "index.md",
"Mathematical Construction" => [
"Motivation " => "construction/motivation.md",
"Construction of smoothed linear interpolation" => "construction/construction_smoothed_linear_interpolation.md",
"Integrating" => "construction/integrating.md",
"Inverting the integral" => "construction/inverting_the_integral.md",
],
"Examples" => "examples.md",
"To Cache or not to Cache" => "cache.md",
"API" => "api.md",
],
format = Documenter.HTML(;
mathengine = Documenter.MathJax(
Dict(:TeX => Dict(:equationNumbers => Dict(:autoNumber => "AMS"))),
),
),
)
deploydocs(; repo = "github.com/SouthEndMusic/SmoothInterpolation.jl.git")
| SmoothInterpolation | https://github.com/SouthEndMusic/SmoothInterpolation.jl.git |
Subsets and Splits