The dynamics of Plasmodium falciparum during the expansion phase of the asexual stage of infection

The dynamics of Plasmodium falciparum during the expansion phase of the asexual stage of infection

https://www.wolframcloud.com/objects/sompob/models/NJWandImmune.nb

 

เขียนcodeแก้ปัญหาจากpantipเล่น

https://pantip.com/topic/38221485/

code สำหรับปัญหานี้

https://www.wolframcloud.com/objects/sompob/test/pantip_01Nov18.nb

Manipulate[
Show[
  Graphics[{EdgeForm[Pink], FaceForm[Blue], 
    Rectangle[{1 - Cos[-15 Degree], 0}, {x, 
      x - (1 - Cos[-15 Degree])}]}],
  Graphics[{EdgeForm[LightBlue], FaceForm[Black], 
    Rotate[Rectangle[{0, 0}], -15 Degree, {1, 0}],
    PlotRange -> {{-2, 2}, {-2, 2}} }],
  Graphics[
   Text["Area of the Big Square:" <> 
     ToString[(x - (1. - Cos[15 Degree]))^2/(0.5*Sin[15 Degree]*
         Cos[15 Degree])], {0.25, 1.5}]]
   ],
 {{x, 1.259, "side"}, 0.1, 2, 0.001}
 ]

 

 

My Green Apple

ทดลองเล่น WolframCloud

เจ๋งมากกกกกก เขียนสั้น deploy ก็ง่าย (เชียร์ให้คนมาใช้กันเยอะๆ 555)

 

NetChain กับ NetGraph

เวลาสร้าง neural network ใน Mathematica นั้นมันจะมีสองคำสั่งที่ใช้กันหลักๆก็คือ NetChain กับ NetGraph แต่สองคำสั่งนี้จะต่างกันตรงที่ NetChain มันจะเรียงแต่ล่ะ layer ต่อๆกันเป็น linear เลยในขณะที่ NetGraph มันจะยืดหยุ่นมากกว่าโดยที่เราสามารถที่จะบอกได้ว่าแต่ล่ะ layer ต่อกันยังไง เช่น

แสดง output จาก ggplot ใน Mathematica

ลองดูตัวอย่างที่ผมเขียนนี้ครับ  ไอเดียก็คือว่าให้มันเขียนภาพเป็นไฟล์ pdf ด้วยคำสั่ง ggsave แล้วเรียกกลับมาใน Mathematica ด้วย Import  โค้ดที่เขียนนี้ดัดแปลงมาจาก https://mathematica.stackexchange.com/questions/16726/how-to-get-a-plot-generated-by-r-returned-in-an-output-cell

 

 

 

วาดกราฟ exponential sums

พอดีว่าไปเห็นกราฟที่วาดจาก Exponential sums จากเวบ https://www.maths.unsw.edu.au/about/exponential-sums แล้วดูว่าสวยดีเลยอยากลองทำดูบ้างด้วย Mathematica

การวาดกราฟจาก exponential sums หรือที่เขียนอยู่ในรูปแบบ \sum_{n=1}^N e^{2\pi if(n)} ที่ทำนี้ก็คือถ้าเราค่อยๆบวกเข้าไปทีละเทอมและเอาค่าที่ได้มาพล็อตกราฟใน complex plane โดยที่แกนนอนคือจำนวนจริงและแกนตั้งคือจำนวนจินตภาพ ลองดูที่โค้ดน่าจะเข้าใจมากขึ้นครับ

fn[n_] := Log[n]^4
NP = 5000;
ls = Accumulate[Table[Exp[2 \[Pi] I fn[n]] // N, {n, 1, NP}]];
Manipulate[
 ListPlot[{Re@#, Im@#}\[Transpose] &@(ls[[1 ;; np]]), Joined -> True, 
  AspectRatio -> Full, PlotStyle -> Black, 
  PlotRange -> {{-5, 70}, {-60, 20}}]
 ,
 {np, 1, NP, 1, Appearance -> "Labeled"}]

 

fn[n_] := n/dd + n^2/mm + n^3/yy /. {dd -> 23, mm -> 11, yy -> 78}
NP = 10000;
ls = Accumulate[Table[Exp[2 \[Pi] I fn[n]] // N, {n, 1, NP}]];
Manipulate[
 ListPlot[{Re@#, Im@#}\[Transpose] &@(ls[[1 ;; np]]), Joined -> True, 
  AspectRatio -> Full, PlotStyle -> Black]
 ,
 {np, 3, NP, 1}]

 

 

 

 

มาลองทำให้โค้ดMathematicaรันเร็วขึ้น

โค้ดที่เขียนด้วยMathematicaหรือภาษา Wolfram นั้นมันจะมีวิธีที่ช่วยให้มันรันได้เร็วขึ้นอยู่หลายวิธีครับ ขึ้นกับปัญหาและวิธีการเขียน ที่จะโชว์ให้ดูนี้ผมก็ใช้เทคนิคง่ายๆด้วยการทำ parallel ด้วยคำสั่ง ParallelTable และ compile ด้วยคำสั่ง Compile ครับ  โค้ดตัวอย่างที่จะเอามาลองนี้เป็นโค้ดที่ใช้วาดรูป Mandelbrot set ครับ

แบบที่ 1 เป็นโค้ดเริ่มต้นที่ยังไม่มีการทำให้มันเร็วครับเขียนโดยใช้ loop จากคำสั่ง Table

AbsoluteTiming[
 test1 = Block[{i, x, p}, 
    Table[i = 0; x = 0. I; p = r + I c; 
     While[Abs@x <= Sqrt[2] && i < 9^3, x = x^2 + p; ++i]; 
     Tanh[Power[i/9^3, (7)^-1]], {c, -1, 1, .01}, {r, -2, 1, .01}]];]

(* เวลาที่ใช้คือ 77.4437 วินาที *)

แบบที่ 2 ในแบบนี้ผมทดลองให้มันรันแบบขนานโดยใช้คำสั่ง ParallelTable เครื่องที่ผมใช้นี้มันมี 4 cores ครับ เวลาก็ลดลง ถ้าคิดง่ายๆก็ใช้เวลาเหลือเกือบๆ 1 ใน 4

AbsoluteTiming[
 test2 = Block[{i, x, p}, 
    ParallelTable[i = 0; x = 0. I; p = r + I c; 
     While[Abs@x <= Sqrt[2] && i < 9^3, x = x^2 + p; ++i]; 
     Tanh[Power[i/9^3, (7)^-1]], {c, -1, 1, .01}, {r, -2, 1, .01}]];]

(* เวลาที่ใช้คือ 23.8938 วินาที *)

แบบที่ 3  แบบนี้ก็คือเอาแบบที่ 1 มา compile เป็น binary code ด้วยคำสั่ง Compile เวลาก็เร็วขึ้นอย่างเห็นได้ชัด

test3 = Compile[{}, 
  Block[{i, x, p}, 
   Table[i = 0; x = 0. I; p = r + I c; 
    While[Abs@x <= Sqrt[2] && i < 9^3, x = x^2 + p; ++i]; 
    Tanh[Power[i/9^3, (7)^-1]], {c, -1, 1, .01}, {r, -2, 1, .01}]]]

AbsoluteTiming[test3[];]

(* เวลาที่ใช้คือ 2.68316 วินาที *)

แบบที่ 4  แบบนี้ก็คือแบบที่ 3 ที่เอามารันแบบขนานด้วยคำสั่ง ParallelTable ซึ่งเวลาที่ใช้ก็เร็วขึ้นอีกกว่าแบบที่ 3

test4 = Compile[{{c, _Real}, {r, _Real}},
   Module[{i, x, p},
    i = 0; x = 0. I; p = r + I c; 
    While[Abs@x <= Sqrt[2] && i < 9^3, x = x^2 + p; ++i]; 
    Tanh[Power[i/9^3, (7)^-1]]
    ]
   ];

ParallelTable[
   test4[c, r], {c, -1, 1, .01}, {r, -2, 1, .01}]; // AbsoluteTiming

(* เวลาที่ใช้คือ 1.04455 วินาที *)

แบบที่ 5 แบบนี้เหมือนกับแบบที่ 4 แต่แทนที่จะให้มัน compile เป็น binary code โดย Mathematica เอง ก็ให้มันแปลงเป็นภาษา C ด้วย option CompilationTarget -> “C” เลยโดยใช้ compiler อย่าง gcc ครับ เวลาก็เร็วขึ้นอีกประมาณ 60% จากแบบที่ 4 ครับ

Needs["CCompilerDriver`GenericCCompiler`"]

$CCompiler = {"Compiler" -> GenericCCompiler, 
   "CompilerInstallation" -> "C:/Rtools/mingw_64", 
   "CompilerName" -> "x86_64-w64-mingw32-gcc.exe"};


test5 = Compile[{{c, _Real}, {r, _Real}},
   Module[{i, x, p},
    i = 0; x = 0. I; p = r + I c; 
    While[Abs@x <= Sqrt[2] && i < 9^3, x = x^2 + p; ++i]; 
    Tanh[Power[i/9^3, (7)^-1]]
    ], CompilationTarget -> "C"];

ParallelTable[
   test5[c, r], {c, -1, 1, .01}, {r, -2, 1, .01}]; // AbsoluteTiming

(* เวลาที่ใช้ 0.393584 วินาที *)