diff --git a/main_SDs.ipynb b/main_SDs.ipynb
new file mode 100644
index 0000000..66d0d04
--- /dev/null
+++ b/main_SDs.ipynb
@@ -0,0 +1,3365 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "using Revise, Plots, ArndtLabTheme, LightGraphs\n",
+ "pyplot()\n",
+ "theme(:arndtlab)\n",
+ "\n",
+ "includet(\"/Users/abdullae/julia_wd/object_oriented_SDs/modules_SDs.jl\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(6791, 4)"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a = SDmoduleInit.Initialize_SD_object(\"../graphs_sticks/GRCh38GenomicSuperDup_sort.tab\"); # \"GRCh38_sort_notel.tab\"\n",
+ "b = SDmoduleInit.Initialize_pyr_object(a.int_DF);\n",
+ "c, ind_arr, ind_arr2 = SDmoduleInit.Initialize_SD_object(\"../graphs_sticks/GRCh38GenomicSuperDup_sort.tab\", comp3=\"filter\");\n",
+ "size(b.int_DF)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 3703 = 0.2308315671362673 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 269 = 0.040414663461538464 of all nodes (or 0.05940302896632848 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 1383 = 0.08621119561151976 of all edges and 0.30815508021390375 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 4488 and Inter = 11554 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{6656, 16042} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "nex = deepcopy(b)\n",
+ "graph_obj = NetworkAnalysis.Initialize_SD_network(b, a.int_DF);\n",
+ "graph_obj.mg"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 2832 = 0.19540467812047196 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 254 = 0.038161057692307696 of all nodes (or 0.05940302896632848 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 1305 = 0.09004346926102257 of all edges and 0.313475858755705 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 4163 and Inter = 10330 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{6656, 14493} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "graph_obj2 = NetworkAnalysis.Initialize_SD_network(nex, c.int_DF)\n",
+ "graph_obj2.mg"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "assign_weights_edges! (generic function with 1 method)"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "using GraphPlot, MetaGraphs\n",
+ "using Distributions\n",
+ "\n",
+ "\n",
+ "function assign_weights_edges!(graph; comp=\"normal\")\n",
+ " cc = connected_components(graph)\n",
+ " cl = map(length, cc)\n",
+ " \n",
+ " for i in vertices(graph)\n",
+ " neis = neighbors(graph, i)\n",
+ " for n in neis\n",
+ " neis2 = neighbors(graph, n)\n",
+ " mat_inds = findall(x -> x in neis, neis2) # findall(x -> (x in neis) && (x != i), neis2)\n",
+ " #if length(mat_inds) > 0\n",
+ " if weights(graph)[i, n] == 1.0 # depends on specified weight\n",
+ " if comp == \"normal\"\n",
+ " wei = 1.001 - (length(mat_inds) + 1)/length(neis)\n",
+ " elseif comp == \"normal_noise\"\n",
+ " wei = 1.001 - (length(mat_inds) + 1)/length(neis) + rand(Uniform(-0.00005, 0.00005))\n",
+ " elseif comp == \"shuffle\"\n",
+ " wei = 1.001 + rand() \n",
+ " end\n",
+ " set_prop!(graph, i, n, :weight, wei)\n",
+ " else\n",
+ " if comp == \"normal\"\n",
+ " wei = minimum([1.001 - (length(mat_inds) + 1)/length(neis), weights(graph)[i, n]])\n",
+ " elseif comp == \"normal_noise\"\n",
+ " wei = minimum([1.001 - (length(mat_inds) + 1)/length(neis), weights(graph)[i, n]]) + rand(Uniform(-0.00005, 0.00005))\n",
+ " elseif comp == \"shuffle\"\n",
+ " wei = minimum([1.001 + rand(), weights(graph)[i, n]])\n",
+ " end\n",
+ " set_prop!(graph, i, n, :weight, wei)\n",
+ " end\n",
+ " end\n",
+ " end\n",
+ "end\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "brussels (generic function with 2 methods)"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "function brussels(graph, N=100)\n",
+ " assign_weights_edges!(graph)\n",
+ " n_deg, ids_hui, edges = graph_nosec_from_graph(graph, comp=\"mst_krus\")\n",
+ " n_degs = deepcopy(n_deg)\n",
+ " for i in 1:(N-1)\n",
+ " assign_weights_edges!(graph, comp=\"normal_noise\")\n",
+ " n_deg, ids_hui, edg = graph_nosec_from_graph(graph, comp=\"mst_krus\")\n",
+ " n_degs = n_degs + n_deg\n",
+ " append!(edges, edg)\n",
+ " end\n",
+ " n_degs = n_degs./N\n",
+ " return n_degs, edges\n",
+ "end\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "new_york (generic function with 1 method)"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "function new_york(graph, N)\n",
+ " edg = brussels(graph, N)[2]\n",
+ " for e in edges(graph)\n",
+ " wei = 1.0 - sum(map(x ->(x.src == e.src) & (x.dst == e.dst) ? 1 : 0, edg))/N\n",
+ " set_prop!(graph, e.src, e.dst, :weight, wei)\n",
+ " end\n",
+ " n_deg, ids_hui, edg = graph_nosec_from_graph(graph, comp=\"mst_krus\")\n",
+ " return n_deg, edg\n",
+ "end\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "stambul (generic function with 1 method)"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# for deletion\n",
+ "\n",
+ "function tokyo(graph)\n",
+ " arr_out = Float64[]\n",
+ " vers = sort(collect(vertices(graph)))\n",
+ " for i in vers\n",
+ " neis = neighbors(graph, i)\n",
+ " gub = induced_subgraph(graph, [i, neis...])[1]\n",
+ " all_sum = sum(1 .- map(x -> get_prop(gub, x, :weight), edges(gub)))\n",
+ " gub = induced_subgraph(graph, neis)[1]\n",
+ " if length(edges(gub)) > 0\n",
+ " oth_sum = sum(1 .- map(x -> get_prop(gub, x, :weight), edges(gub)))\n",
+ " res = length(neis)*(all_sum - oth_sum)/all_sum\n",
+ " else\n",
+ " res = float(length(neis))\n",
+ " end\n",
+ " append!(arr_out, res)\n",
+ " end\n",
+ " return arr_out\n",
+ "end\n",
+ " \n",
+ "function stambul(graph)\n",
+ " gr = SimpleGraph(nv(graph), 0)\n",
+ " vers = sort(collect(vertices(graph)))\n",
+ " for i in vers\n",
+ " neis = neighbors(graph, i)\n",
+ " weis = collect(map(x -> x > i ? get_prop(graph, Edge(i, x), :weight) : get_prop(graph, Edge(x, i), :weight), neis))\n",
+ " node = neis[weis .== minimum(weis)][1]\n",
+ " if !(has_edge(gr, i, node))\n",
+ " add_edge!(gr, i, node)\n",
+ " end\n",
+ " end\n",
+ " arr_out = collect(map(x -> length(neighbors(gr, x)), vers))\n",
+ " return arr_out, gr\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"done\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "using LightGraphs, Histograms\n",
+ "\n",
+ "\n",
+ "function custom_cmp(x::String)\n",
+ " number_idx = findfirst(isdigit, x)\n",
+ " str, num = SubString(x, 1, number_idx-1), SubString(x, number_idx, length(x))\n",
+ " return str, parse(Int, num)\n",
+ "end\n",
+ "\n",
+ "\n",
+ "function graph_nosec_from_graph(graph; comp=\"mst_krus\", comp_vis=false)\n",
+ " if comp == \"mst_krus\"\n",
+ " edg_list = kruskal_mst(graph)\n",
+ " gr1 = induced_subgraph(graph, edg_list)[1]\n",
+ " elseif comp == \"mst_prim\"\n",
+ " ids, n_deg_int = [], []\n",
+ " ccs = connected_components(graph)\n",
+ " for cc in ccs\n",
+ " cc_gr = induced_subgraph(graph, cc)[1]\n",
+ " edg_list = prim_mst(cc_gr)\n",
+ " gr1 = induced_subgraph(cc_gr, edg_list)[1]\n",
+ " emap = vertices(gr1)\n",
+ " append!(ids, map(x -> get_prop(gr1, x, :id), emap))\n",
+ " append!(n_deg_int, map(x -> length(neighbors(gr1, x)), emap))\n",
+ " end\n",
+ " n_deg_int = n_deg_int[sortperm(ids, rev=false, by=custom_cmp)]\n",
+ " ids = sort(ids, by=custom_cmp)\n",
+ " return n_deg_int, ids # maybe problem!!! only 2 outputs\n",
+ " elseif comp == \"all\"\n",
+ " gr1 = graph\n",
+ " edg_list = edges(graph)\n",
+ " end\n",
+ " emap = vertices(gr1)\n",
+ " ids = map(x -> get_prop(gr1, x, :id), emap)\n",
+ " n_deg_int = map(x -> length(neighbors(gr1, x)), emap)\n",
+ " n_deg_int = n_deg_int[sortperm(ids, rev=false, by=custom_cmp)]\n",
+ " ids = sort(ids, by=custom_cmp)\n",
+ " if comp_vis\n",
+ " n_deg = convert.(UInt64, n_deg_int);\n",
+ " nd_h = Histograms.Histogram(n_deg, scale=:log);\n",
+ " p = plot(nd_h, yscale=:log10, xscale=:log10, line=false, markershape=:auto)\n",
+ " x = range(1, 30, length=10); y = 1.0*x.^(-3);\n",
+ " p = plot!(x, y, label=\"a = -3\")\n",
+ " gui(p)\n",
+ " end\n",
+ " return n_deg_int, ids, edg_list\n",
+ "end\n",
+ "\n",
+ "assign_weights_edges!(graph_obj.mg);\n",
+ "assign_weights_edges!(graph_obj2.mg) #, comp=\"normal_noise\");\n",
+ "#assign_weights_edges!(graph_obj2.mg, \"shuffle\");\n",
+ "n_deg, ids_hui = graph_nosec_from_graph(graph_obj2.mg, comp=\"mst_krus\")[1:2];\n",
+ "display(\"done\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 148,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.00010178117048342816"
+ ]
+ },
+ "execution_count": 148,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# to recognize the weights min difference\n",
+ "\n",
+ "weis = sort(collect(map(x -> get_prop(graph_obj.mg, x, :weight), edges(graph_obj.mg))))\n",
+ "difs = sort(weis[2:end] - weis[1:end-1])\n",
+ "min_dif = difs[difs .> 0][1]\n",
+ "# 0.0001"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"These are top jumpers:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "
| chr | coor_s | coor_e | ids |
---|
| Int64 | Int64 | Int64 | String |
---|
10 rows × 4 columns
1 | 3 | 125690307 | 125935167 | id1230 |
---|
2 | 9 | 39588991 | 40873597 | id3253 |
---|
3 | 1 | 8893201 | 8894618 | id36 |
---|
4 | 1 | 96446864 | 96448625 | id241 |
---|
5 | 15 | 22358242 | 22768868 | id4943 |
---|
6 | 7 | 57497244 | 57823866 | id2596 |
---|
7 | 1 | 101786252 | 101787301 | id247 |
---|
8 | 2 | 131791143 | 132220279 | id819 |
---|
9 | 7 | 56787891 | 57137555 | id2581 |
---|
10 | 15 | 19987818 | 20428912 | id4928 |
---|
"
+ ],
+ "text/latex": [
+ "\\begin{tabular}{r|cccc}\n",
+ "\t& chr & coor\\_s & coor\\_e & ids\\\\\n",
+ "\t\\hline\n",
+ "\t& Int64 & Int64 & Int64 & String\\\\\n",
+ "\t\\hline\n",
+ "\t1 & 3 & 125690307 & 125935167 & id1230 \\\\\n",
+ "\t2 & 9 & 39588991 & 40873597 & id3253 \\\\\n",
+ "\t3 & 1 & 8893201 & 8894618 & id36 \\\\\n",
+ "\t4 & 1 & 96446864 & 96448625 & id241 \\\\\n",
+ "\t5 & 15 & 22358242 & 22768868 & id4943 \\\\\n",
+ "\t6 & 7 & 57497244 & 57823866 & id2596 \\\\\n",
+ "\t7 & 1 & 101786252 & 101787301 & id247 \\\\\n",
+ "\t8 & 2 & 131791143 & 132220279 & id819 \\\\\n",
+ "\t9 & 7 & 56787891 & 57137555 & id2581 \\\\\n",
+ "\t10 & 15 & 19987818 & 20428912 & id4928 \\\\\n",
+ "\\end{tabular}\n"
+ ],
+ "text/plain": [
+ "10×4 DataFrames.DataFrame\n",
+ "│ Row │ chr │ coor_s │ coor_e │ ids │\n",
+ "│ │ \u001b[90mInt64\u001b[39m │ \u001b[90mInt64\u001b[39m │ \u001b[90mInt64\u001b[39m │ \u001b[90mString\u001b[39m │\n",
+ "├─────┼───────┼───────────┼───────────┼────────┤\n",
+ "│ 1 │ 3 │ 125690307 │ 125935167 │ id1230 │\n",
+ "│ 2 │ 9 │ 39588991 │ 40873597 │ id3253 │\n",
+ "│ 3 │ 1 │ 8893201 │ 8894618 │ id36 │\n",
+ "│ 4 │ 1 │ 96446864 │ 96448625 │ id241 │\n",
+ "│ 5 │ 15 │ 22358242 │ 22768868 │ id4943 │\n",
+ "│ 6 │ 7 │ 57497244 │ 57823866 │ id2596 │\n",
+ "│ 7 │ 1 │ 101786252 │ 101787301 │ id247 │\n",
+ "│ 8 │ 2 │ 131791143 │ 132220279 │ id819 │\n",
+ "│ 9 │ 7 │ 56787891 │ 57137555 │ id2581 │\n",
+ "│ 10 │ 15 │ 19987818 │ 20428912 │ id4928 │"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#n_deg_tokyo = tokyo(graph_obj2.mg)\n",
+ "#n_deg_stambul = stambul(graph_obj2.mg)[1]\n",
+ "#vers = sort(collect(vertices(graph_obj2.mg)))\n",
+ "#ids = map(x -> get_prop(graph_obj2.mg, x, :id), vers)\n",
+ "\n",
+ "zaz = ids_hui[sortperm(n_deg, rev=true)[1:10]] # different ids and ndegs also possible\n",
+ "display(\"These are top jumpers:\")\n",
+ "display(b.int_DF[findfirst.(isequal.(zaz), (b.int_DF[!, :ids],)), :])\n",
+ "b.int_DF[!, :jumps] = zeros(Int64, size(b.int_DF)[1])\n",
+ "\n",
+ "for (i, val) in enumerate(ids_hui)\n",
+ " b.int_DF[b.int_DF[!,:ids] .== val, :jumps] .= n_deg[i] \n",
+ "end\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 111,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"../temp/df_ws_jumps.csv\""
+ ]
+ },
+ "execution_count": 111,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#using CSV\n",
+ "\n",
+ "#CSV.write(\"../temp/df_ws_jumps.csv\", b.int_DF)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#using GraphIO, ParserCombinator\n",
+ "\n",
+ "#edges(graph_obj.mg)\n",
+ "#kruskal_mst(graph_obj.mg)\n",
+ "#savegraph(\"./grav\", graph_obj.mg, \"graph\", GraphIO.EdgeList.EdgeListFormat())"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 112,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Human:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 6342 = 0.16994024491545862 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 640 = 0.050878448207329674 of all nodes (or 0.03175102169129205 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 2203 = 0.05903159248640103 of all edges and 0.30776753283039954 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 7158 and Inter = 30162 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{12579, 37319} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "execution_count": 112,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "a_hum = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Human_SDs_denovo.txt\", 2, \"both\"); \n",
+ "b_hum = SDmoduleInit.Initialize_pyr_object(a_hum.int_DF);\n",
+ "display(\"Human:\")\n",
+ "graph_hum = NetworkAnalysis.Initialize_SD_network(b_hum, a_hum.int_DF);\n",
+ "graph_hum.mg"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 113,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a_gor = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Gorilla_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_gor = SDmoduleInit.Initialize_pyr_object(a_gor.int_DF);\n",
+ "a_chi = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Chicken_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_chi = SDmoduleInit.Initialize_pyr_object(a_chi.int_DF);\n",
+ "a_cel = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Celegans_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_cel = SDmoduleInit.Initialize_pyr_object(a_cel.int_DF);\n",
+ "#a_cmp = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Chimp_SDs_denovo.txt\", 2, \"both\");\n",
+ "#b_cmp = SDmoduleInit.Initialize_pyr_object(a_cmp.int_DF);\n",
+ "#a_dro = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Drosophila_SDs_denovo.txt\", 2, \"both\");\n",
+ "#b_dro = SDmoduleInit.Initialize_pyr_object(a_dro.int_DF);\n",
+ "#a_zfi = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Zebra_finch_SDs_denovo.txt\", 2, \"both\");\n",
+ "#b_zfi = SDmoduleInit.Initialize_pyr_object(a_zfi.int_DF);\n",
+ "a_zeb = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Zebrafish_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_zeb = SDmoduleInit.Initialize_pyr_object(a_zeb.int_DF);\n",
+ "\n",
+ "#a_yea = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Yeast_SDs_denovo.txt\", 2, \"both\");\n",
+ "#b_yea = SDmoduleInit.Initialize_pyr_object(a_yea.int_DF);\n",
+ "#a_pla = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Platypus_SDs_denovo.txt\", 2, \"both\");\n",
+ "#b_pla = SDmoduleInit.Initialize_pyr_object(a_pla.int_DF);\n",
+ "#a_cow = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Cow_SDs_denovo.txt\", 2, \"both\");\n",
+ "#b_cow = SDmoduleInit.Initialize_pyr_object(a_cow.int_DF);\n",
+ "a_sti = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Stickleback_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_sti = SDmoduleInit.Initialize_pyr_object(a_sti.int_DF);\n",
+ "\n",
+ "a_rat = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Rat_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_rat = SDmoduleInit.Initialize_pyr_object(a_rat.int_DF);\n",
+ "a_mus = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Mouse_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_mus = SDmoduleInit.Initialize_pyr_object(a_mus.int_DF);\n",
+ "a_gib = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Gibbon_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_gib = SDmoduleInit.Initialize_pyr_object(a_gib.int_DF);\n",
+ "a_dog = SDmoduleInit.Initialize_SD_object(\"./oth_genomes/Dog_SDs_denovo.txt\", 2, \"both\");\n",
+ "b_dog = SDmoduleInit.Initialize_pyr_object(a_dog.int_DF);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 114,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Gorilla:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 4175 = 0.09790586966207819 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 1733 = 0.05602068854048812 of all nodes (or 0.012998712998712999 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 10467 = 0.24545646413244845 of all edges and 0.5311041201542521 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 19708 and Inter = 23308 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{30935, 42643} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Chicken:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 3293 = 0.1925505788796632 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 438 = 0.13821394761754496 of all nodes (or 0.12190706095353047 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 1449 = 0.08472693252251198 of all edges and 0.23247232472324722 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 6233 and Inter = 10941 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{3169, 17102} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Celegans:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 230 = 0.10459299681673488 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 186 = 0.1183206106870229 of all nodes (or 0.23529411764705882 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 368 = 0.16734879490677582 of all edges and 0.4471445929526124 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 823 and Inter = 1376 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{1572, 2199} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Zebrafish:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 86885 = 0.14449790367028167 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 2531 = 0.07347946000870954 of all nodes (or 0.011679676206996241 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 4745 = 0.007891380018593389 of all edges and 0.08422977242872866 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 56334 and Inter = 544994 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{34445, 601289} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Stickleback:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 3830 = 0.06510726549484921 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 429 = 0.07613132209405502 of all nodes (or 0.0698961937716263 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 2091 = 0.03554550708870227 of all edges and 0.3869356032568468 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 5404 and Inter = 53439 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{5635, 58826} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Rat:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 44104 = 0.24019431646134912 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 2793 = 0.07775828948467385 of all nodes (or 0.011202307009760427 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 18489 = 0.10069274254158089 of all edges and 0.41790606211292436 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 44242 and Inter = 139569 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{35919, 183618} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Mouse:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 7268 = 0.04374492160462247 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 628 = 0.0425301368007585 of all nodes (or 0.027094091610220642 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 3793 = 0.022829456197899424 of all edges and 0.2703492516037063 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 14030 and Inter = 152115 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{14766, 166145} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Gibbon:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 25515 = 0.05747709026031952 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 334 = 0.011369825708061002 of all nodes (or 0.013685173266488262 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 10320 = 0.023247641445678913 of all edges and 0.3398985574072854 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 30362 and Inter = 413604 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{29376, 443916} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Dog:\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Double edges = 2087 = 0.03349489632149965 of all edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Self loops = 281 = 0.01524026467078859 of all nodes (or 0.021740300274444384 without filtering singleton nodes)\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Tandem edges = 1788 = 0.02869615458689093 of all edges and 0.4079397672826831 of all intra\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "\"Intra = 4383 and Inter = 57948 edges\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "{18438, 62308} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "\n",
+ "display(\"Gorilla:\")\n",
+ "graph_goril = NetworkAnalysis.Initialize_SD_network(b_gor, a_gor.int_DF);\n",
+ "display(graph_goril.mg)\n",
+ "display(\"Chicken:\")\n",
+ "graph_chick = NetworkAnalysis.Initialize_SD_network(b_chi, a_chi.int_DF);\n",
+ "display(graph_chick.mg)\n",
+ "display(\"Celegans:\")\n",
+ "graph_celeg = NetworkAnalysis.Initialize_SD_network(b_cel, a_cel.int_DF);\n",
+ "display(graph_celeg.mg)\n",
+ "#display(\"Chimp:\")\n",
+ "#graph_chimp = NetworkAnalysis.Initialize_SD_network(b_cmp, a_cmp.int_DF);\n",
+ "#display(\"Drosophila:\")\n",
+ "#graph_drosop = NetworkAnalysis.Initialize_SD_network(b_dro, a_dro.int_DF);\n",
+ "#display(\"Zebra finch:\")\n",
+ "#graph_zfinch = NetworkAnalysis.Initialize_SD_network(b_zfi, a_zfi.int_DF);\n",
+ "#display(graph_zfinch.mg)\n",
+ "display(\"Zebrafish:\")\n",
+ "graph_zebrafi = NetworkAnalysis.Initialize_SD_network(b_zeb, a_zeb.int_DF);\n",
+ "display(graph_zebrafi.mg)\n",
+ "\n",
+ "#display(\"Yeast:\")\n",
+ "#graph_yeast = NetworkAnalysis.Initialize_SD_network(b_yea, a_yea.int_DF);\n",
+ "#display(\"Platypus:\")\n",
+ "#graph_platy = NetworkAnalysis.Initialize_SD_network(b_pla, a_pla.int_DF);\n",
+ "#display(\"Cow:\")\n",
+ "#graph_cow = NetworkAnalysis.Initialize_SD_network(b_cow, a_cow.int_DF);\n",
+ "display(\"Stickleback:\")\n",
+ "graph_stick = NetworkAnalysis.Initialize_SD_network(b_sti, a_sti.int_DF);\n",
+ "display(graph_stick.mg)\n",
+ "display(\"Rat:\")\n",
+ "graph_rat = NetworkAnalysis.Initialize_SD_network(b_rat, a_rat.int_DF);\n",
+ "display(graph_rat.mg)\n",
+ "display(\"Mouse:\")\n",
+ "graph_mouse = NetworkAnalysis.Initialize_SD_network(b_mus, a_mus.int_DF);\n",
+ "display(graph_mouse.mg)\n",
+ "display(\"Gibbon:\")\n",
+ "graph_gibbon = NetworkAnalysis.Initialize_SD_network(b_gib, a_gib.int_DF);\n",
+ "display(graph_gibbon.mg)\n",
+ "display(\"Dog:\")\n",
+ "graph_dog = NetworkAnalysis.Initialize_SD_network(b_dog, a_dog.int_DF);\n",
+ "display(graph_dog.mg)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 115,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "\"Human predicted f = 0.5298410636885584\""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "4-element Array{Int64,1}:\n",
+ " 1571\n",
+ " 122\n",
+ " 107\n",
+ " 199"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "using LightGraphs, Optim\n",
+ "\n",
+ "function calc_inds_4_f(graph)\n",
+ " ccs = connected_components(graph)\n",
+ " lens = map(length, ccs)\n",
+ " ind_2_2, ind_3_2, ind_3_3 = 0, 0, 0\n",
+ " ind_2_2 = length(lens[lens .== 2])\n",
+ " \n",
+ " ind_more = length(lens[lens .> 3])\n",
+ " \n",
+ " for comps in ccs[lens .== 3]\n",
+ " neis = map(x -> length(neighbors(graph, x)), comps)\n",
+ " if sum(neis)/2 == 2\n",
+ " ind_3_2 += 1 \n",
+ " elseif sum(neis)/2 == 3\n",
+ " ind_3_3 += 1\n",
+ " end\n",
+ " end\n",
+ " \n",
+ " return [ind_2_2, ind_3_2, ind_3_3, ind_more]\n",
+ "end\n",
+ " \n",
+ "function predict_f(f, f_fin, ind_more, N)\n",
+ " for i in 1:ind_more\n",
+ " p = (0.6*f)/(0.6*f + 0.4*(1-f))\n",
+ " f = p*(f*N-1)/(N-1) + (1-p)*(f*N)/(N-1)\n",
+ " N -= 1\n",
+ " end\n",
+ " \n",
+ " return abs(f - f_fin)\n",
+ "end\n",
+ "\n",
+ "function calc_f_species(graph, specie::String=\"Human\")\n",
+ " ind_2_2, ind_3_2, ind_3_3, ind_more = calc_inds_4_f(graph)\n",
+ " f_fin = ind_3_3/(ind_3_3 + ind_3_2); N = ind_3_2 + ind_3_3 + ind_more;\n",
+ " out = optimize(x -> predict_f(x, f_fin, ind_more, N), 0.0, 1.0)\n",
+ " display(\"$(specie) predicted f = $(out.minimizer)\")\n",
+ " return ind_2_2, ind_3_2, ind_3_3, ind_more\n",
+ "end\n",
+ " \n",
+ "ind_2_2, ind_3_2, ind_3_3, ind_more = calc_f_species(graph_obj.mg, \"Human\")\n",
+ "display([ind_2_2, ind_3_2, ind_3_3, ind_more])\n",
+ "\n",
+ "#calc_f_species(graph_dog.mg, \"Dog\")\n",
+ "#calc_f_species(graph_mouse.mg, \"Mouse\")\n",
+ "#calc_f_species(graph_rhesus.mg, \"Rhesus\")\n",
+ "#calc_f_species(graph_chick.mg, \"Chick\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 116,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Results of Nonlinear Solver Algorithm\n",
+ " * Algorithm: Trust-region with dogleg and autoscaling\n",
+ " * Starting Point: [0.0005, 0.5, 2000.0]\n",
+ " * Zero: [9.77297e-5, 0.494198, 1876.71]\n",
+ " * Inf-norm of residuals: 0.000000\n",
+ " * Iterations: 7\n",
+ " * Convergence: true\n",
+ " * |x - x'| < 0.0e+00: false\n",
+ " * |f(x)| < 1.0e-08: true\n",
+ " * Function Calls (f): 8\n",
+ " * Jacobian Calls (df/dx): 8"
+ ]
+ },
+ "execution_count": 116,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "using NLsolve, QuadGK, Calculus\n",
+ "\n",
+ "function f!(y, incond)\n",
+ " Ns = [1571, 122, 107, 199]\n",
+ " N = sum(Ns)\n",
+ " delta, f, t = incond\n",
+ " pi = 1.0\n",
+ " N_2, N_3_2, N_3_3, N_more = Ns\n",
+ " y[1] = (pi/(2*delta))*(1 - exp(-2*delta*t)) - N_2\n",
+ " y[2] = (pi*(1-f)/(4*delta))*(1 - 2*exp(-2*delta*t) + exp(-4*delta*t)) - N_3_2\n",
+ " y[3] = (pi*f/(6*delta))*(1 - 1.5*exp(-2*delta*t) + 0.5*exp(-6*delta*t)) - N_3_3\n",
+ " qq(x) = pi*(1-f)*(1 - 2*exp(-2*delta*x) + exp(-4*delta*x)) + pi*f*(1 - 1.5*exp(-2*delta*x) + 0.5*exp(-6*delta*x))\n",
+ " #y[4] = quadgk(qq, 0, t)[1] - N_more\n",
+ " #y[4] = t - y[1] + y[2] + y[3] - N_2\n",
+ "end\n",
+ "\n",
+ "nlsolve(f!, [0.0005, 0.5, 2000], ftol=1e-8)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 117,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "g! (generic function with 1 method)"
+ ]
+ },
+ "execution_count": 117,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "function g!(G, incond)\n",
+ " delta, f, t = incond\n",
+ " pi = 1.0\n",
+ " Ns = [1571, 122, 107, 199]\n",
+ " weis = 1 ./ Ns\n",
+ " \n",
+ " y1 = (pi/(2*delta))*(1 - exp(-2*delta*t))\n",
+ " y2 = (pi*(1-f)/(4*delta))*(1 - 2*exp(-2*delta*t) + exp(-4*delta*t))\n",
+ " y3 = (pi*f/(6*delta))*(1 - 1.5*exp(-2*delta*t) + 0.5*exp(-6*delta*t))\n",
+ " c1 = (f/12 - 3/4)*pi/delta\n",
+ " y4 = c1 - f*pi*exp(-6*delta*t)/(12*delta) + f*pi*exp(-4*delta*t)/(4*delta) - \n",
+ " f*pi*exp(-2*delta*t)/(4*delta) - pi*exp(-4*delta*t)/(4*delta) + pi*exp(-2*delta*t)/delta + pi*t\n",
+ " ys = [y1, y2, y3, y4]\n",
+ " \n",
+ " K = zeros(4, 3)\n",
+ " \n",
+ " K[1,1] = -(pi*exp(-2*delta*t)*(-2*delta*t + exp(2*delta*t) - 1))/(2*delta^2)\n",
+ " K[1,2] = 0.0\n",
+ " K[1,3] = pi*exp(-2*delta*t)\n",
+ " \n",
+ " K[2,1] = ((f - 1)*pi*exp(-4*delta*t)*(exp(2*delta*t) - 1)*(-4*delta*t + exp(2*delta*t) - 1))/(4*delta^2)\n",
+ " K[2,2] = -(pi*exp(-4*delta*t)*(exp(2*delta*t) - 1)^2)/(4*delta)\n",
+ " K[2,3] = (1 - f)*pi*exp(-4*delta*t)*(exp(2*delta*t) - 1)\n",
+ " \n",
+ " K[3,1] = f*pi*exp(-6*delta*t)*(6*delta*t*(exp(4*delta*t) - 1) + 3*exp(4*delta*t) - 2*exp(6*delta*t) - 1)/(12*delta^2)\n",
+ " K[3,2] = pi*(exp(-6*delta*t) - 3*exp(-2*delta*t) + 2)/(12*delta)\n",
+ " K[3,3] = 0.5*f*pi*exp(-6*delta*t)*(exp(4*delta*t) - 1)\n",
+ " \n",
+ " coef2 = 0.5*exp(-6*delta*t)/(delta^2)\n",
+ " K[4,1] = coef2*(-0.5*f*pi*exp(2*delta*t) + 0.5*f*pi*exp(4*delta*t) - 2*f*delta*pi*t*exp(2*delta*t) +\n",
+ " f*delta*pi*t*exp(4*delta*t) + f*delta*pi*t + f*pi/6 + 0.5*pi*exp(2*delta*t) - 2*pi*exp(4*delta*t) + \n",
+ " 2*delta*pi*t*exp(2*delta*t) - 4*delta*pi*t*exp(4*delta*t))\n",
+ " \n",
+ " coef1 = pi*exp(-6*delta*t)/delta\n",
+ " K[4,2] = coef1*(0.25*exp(2*delta*t) - 0.25*exp(4*delta*t) - 1/12)\n",
+ " K[4,3] = pi*(1 + (0.5*f - 2)*exp(-2*delta*t) + (1 - f)*exp(-4*delta*t) + 0.5*f*exp(-6*delta*t))\n",
+ " \n",
+ " G = map(x -> -sum(K[:,x].*weis.*sign.(ys - Ns)), 1:3)\n",
+ " display(G)\n",
+ "end"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 118,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ " * Status: success\n",
+ "\n",
+ " * Candidate solution\n",
+ " Minimizer: [3.19e-04, 5.20e-01, 1.32e+03]\n",
+ " Minimum: 4.317710e-01\n",
+ "\n",
+ " * Found with\n",
+ " Algorithm: Nelder-Mead\n",
+ " Initial Point: [5.00e-04, 5.00e-01, 2.00e+03]\n",
+ "\n",
+ " * Convergence measures\n",
+ " √(Σ(yᵢ-ȳ)²)/n ≤ 1.0e-08\n",
+ "\n",
+ " * Work counters\n",
+ " Seconds run: 0 (vs limit Inf)\n",
+ " Iterations: 135\n",
+ " f(x) calls: 264\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "using Optim, Distances, QuadGK\n",
+ "\n",
+ "\n",
+ "function ff!(incond)\n",
+ " Ns = [1571, 122, 107, 199]\n",
+ " N = sum(Ns)\n",
+ " delta, f, t = incond\n",
+ " pi = 1.0\n",
+ " N_2, N_3_2, N_3_3, N_more = Ns\n",
+ " weis = 1 ./ Ns\n",
+ " y = Float64[0.0, 0.0, 0.0, 0.0]\n",
+ " y[1] = (pi/(2*delta))*(1 - exp(-2*delta*t))\n",
+ " y[2] = (pi*(1-f)/(4*delta))*(1 - 2*exp(-2*delta*t) + exp(-4*delta*t))\n",
+ " y[3] = (pi*f/(6*delta))*(1 - 1.5*exp(-2*delta*t) + 0.5*exp(-6*delta*t))\n",
+ " #qq(x) = pi*(1-f)*(1 - 2*exp(-2*delta*x) + exp(-4*delta*x)) + pi*f*(1 - 1.5*exp(-2*delta*x) + 0.5*exp(-6*delta*x))\n",
+ " #y[4] = quadgk(qq, 0, t)[1]\n",
+ " c1 = (f/12 - 3/4)*pi/delta\n",
+ " y[4] = c1 - f*pi*exp(-6*delta*t)/(12*delta) + f*pi*exp(-4*delta*t)/(4*delta) - \n",
+ " f*pi*exp(-2*delta*t)/(4*delta) - pi*exp(-4*delta*t)/(4*delta) + pi*exp(-2*delta*t)/delta + pi*t\n",
+ " return wcityblock(y, Ns, weis) # weighted cityblock distance \"wminkowski try\"\n",
+ "end\n",
+ "\n",
+ "res = optimize(ff!, [0.0005, 0.5, 2000], NelderMead())\n",
+ "display(res)\n",
+ "\n",
+ "#res = optimize(ff!, [0.0005, 0.5, 2000], Newton(), Optim.Options(iterations=10000, x_tol=1e-12, allow_f_increases=true))\n",
+ "#display(res)\n",
+ "#res = optimize(ff!, [0.0005, 0.5, 2000], GradientDescent(), Optim.Options(iterations=10000, x_tol=1e-12, allow_f_increases=true))\n",
+ "#display(res)\n",
+ "#res = optimize(ff!, [0.0005, 0.5, 2000], LBFGS(), Optim.Options(iterations=10000, x_tol=1e-12, allow_f_increases=true))\n",
+ "#display(res)\n",
+ "\n",
+ "#Optim.abs_tol(res)\n",
+ "#Candidate solution\n",
+ "# Minimizer: [3.19e-04, 5.20e-01, 1.32e+03]\n",
+ "# Minimum: 4.317710e-01"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 296,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#using BSON, LightGraphs\n",
+ "\n",
+ "#bson(\"sd_network_graph.bson\", Dict(\"sd_network\" => graph_obj.mg))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 119,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "1.4801903290282366"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "1.4169809598224496"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "PyPlot.Figure(PyObject