https://wiki.cdot.senecacollege.ca/w/api.php?action=feedcontributions&user=Tqyu&feedformat=atomCDOT Wiki - User contributions [en]2021-06-23T23:30:56ZUser contributionsMediaWiki 1.30.0https://wiki.cdot.senecacollege.ca/w/index.php?title=GAM531/DPS931_Teams_20143&diff=107129GAM531/DPS931 Teams 201432014-12-06T17:21:17Z<p>Tqyu: /* FL4T */</p>
<hr />
<div><big><big> Game Engine Foundations</big></big><br /><br />
{{GAM531/DPS931 Index | 20143}}<br />
= Team and Project Index =<br />
<br />
You can find a sample team page template[[GAM531/DPS931_Sample_Team_Page | here]]<br />
<br />
== [[GAM531/DPS931 Sample Team Page| Sample Team]] ==<br />
'''Game Name'''<br />
# [mailto:chris.szalwinski@senecacollege.ca?subject=DPS931 Chris Szalwinski]<br />
# [mailto:jp.hughes@senecacollege.ca?subject=GAM531 Joseph Hughes]<br />
# [mailto:jp.hughes@senecacollege.ca;chris.szalwinski@senecacollege.ca?subject=GAM531_DPS931 eMail All]<br />
<br />
== [[GAM531/Team Slice| Team Slice]] ==<br />
'''Game Name'''<br />
# [mailto:bhoover1@myseneca.ca?subject=GAM531 Bradly Hoover]<br />
# [mailto:bczunyi@myseneca.ca?subject=GAM531 Balint Czunyi]<br />
# [mailto:nramkay@myseneca?subject=GAM531 Nick Ramkay]<br />
# [mailto:bhoover1@myseneca?subject=GAM531;bczunyi@myseneca.ca?subject=GAM531;bczunyi@myseneca.ca?subject=GAM531 eMail All]<br />
<br />
== [[GAM531/Team A| Team A]] ==<br />
'''Game Name'''<br />
# [mailto:jswilkin@myseneca.ca?subject=GAM531 Justin Wilkin]<br />
# [mailto:drudeshko@myseneca.ca?subject=GAM531 Dima Rudeshko]<br />
# [mailto:dwandja@myseneca?subject=GAM531 Davson Wandja]<br />
# [mailto:jswilkin@myseneca;drudeshko@myseneca.ca;dwandja@myseneca.ca?subject=GAM531 eMail All]<br />
<br />
== [[GAM531/Team RECursion| Team RECursion]] ==<br />
'''OpenGL DDS Loader'''<br />
# [mailto:rrblaga@senecacollege.ca?subject=GAM531 Raymond Blaga]<br />
# [mailto:ekwan10@myseneca.ca?subject=GAM531 Elliot Kwan]<br />
# [mailto:cmarkieta@myseneca.ca?subject=GAM531 Christopher Markieta]<br />
# [mailto:rrblaga@senecacollege.ca?subject=GAM531;ekwan10@myseneca.ca?subject=GAM531;cmarkieta@myseneca.ca?subject=GAM531 eMail All]<br />
<br />
== [[GAM531/TeamGAM| Team GAM]] ==<br />
'''Game Name'''<br />
# [mailto:jrona@myseneca.ca?subject=GAM531 Jan Ona]<br />
# [mailto:cchoi12@myseneca.ca?subject=GAM531 Chiyoung Choi (Chris)]<br />
# [mailto:ryurash@myseneca?subject=GAM531 Ruslan Yurash]<br />
# [mailto:jrona@myseneca.ca?subject=GAM531;cchoi12@myseneca.ca?subject=GAM531;ryurash@myseneca?subject=GAM531 eMail All]<br />
<br />
== [[Skynet/GAM531| SkyNet]] ==<br />
'''Game Name'''<br />
# [mailto:mmwang2@myseneca.ca?subject=GAM531 Michael Wang]<br />
# [mailto:bpereira5@myseneca.ca?subject=GAM531 Bruno Pereira]<br />
# [mailto:mmwang2@myseneca.ca?subject=GAM531;bpereira5@myseneca?subject=GAM531 eMail All]<br />
<br />
== [[GAM531/HeadCrab| HeadCrab]] ==<br />
'''Game Name'''<br />
# [mailto:wchamilton@myseneca.ca?subject=DPS931 Wesley Hamilton]<br />
# [mailto:rlanderson@myseneca.ca?subject=DPS931 Rene Leon Anderson]<br />
# [mailto:mrtait1@myseneca.ca?subject=DPS931 Matthew R Tait]<br />
# [mailto:wchamilton@myseneca.ca;rlanderson@myseneca.ca;mrtait1@myseneca.ca?subject=GAM531_DPS931 eMail All]<br />
<br />
== [[DPS931/GoodName| GoodName]] ==<br />
'''Game Name'''<br />
# [mailto:jtwieb@myseneca.ca?subject=DPS931 Jordan Wieb]<br />
# [mailto:svaghei@myseneca.ca?subject=DPS931 Shayan Vaghei]<br />
# [mailto:third@myseneca.ca?subject=DPS931 A Third Person Probably]<br />
# [mailto:jtwieb@myseneca.ca;svaghei@myseneca.ca;third@myseneca.ca?subject=GAM531_DPS931 eMail All]<br />
<br />
== [[DPS931/FL4T| FL4T]] ==<br />
'''Game Name'''<br />
# [mailto:tqyu@myseneca.ca?subject=DPS931 Tony Yu]<br />
# [mailto:bkumar3@myseneca.ca@myseneca.ca?subject=DPS931 Barath Kumar]<br />
# [mailto:jyin15@myseneca.ca?subject=DPS931 Jay Yin]<br />
# [mailto:tqyu@myseneca.ca;bkumar3@myseneca.ca@myseneca.ca;jyin15@myseneca.ca?subject=GAM531_DPS931 eMail All]<br />
<br />
== [[GAM531/Brazuca| Brazuca]] ==<br />
'''Game Name'''<br />
# [[User:Bruno Di Giuseppe Cardoso de Carvalh | Bruno Di Giuseppe]] ||[mailto:bdigiuseppecardosode@myseneca.ca?subject=gam531 bdigiuseppecardosdoe] || [https://bitbucket.org/bgcc bgcc]<br />
# [[User:Karina Cristina Sayuri Nishimura | Karina Nishimura]] ||[mailto:kcsayurinishimura@myseneca.ca?subject=gam531 kcsayurinishimura] || [https://bitbucket.org/karinanishimura karinanishimura]<br />
#[mailto:kcsayurinishimura@myseneca.ca;bdigiuseppecardosode@myseneca.ca?subject=gam531 Group Mail]<br />
<br />
== [[GAM531/TeamHu3|Hu3]] ==<br />
<br />
'''Game Name'''<br />
# [mailto:chdeandradesilva@myseneca.ca?subject=DPS931 Carlos Silva]<br />
# [mailto:rfonteldeandrade@myseneca.ca?subject=GAM531 Renato Andrade]<br />
# [mailto:chdeandradesilva@myseneca.ca;rfonteldeandrade@myseneca.ca?subject=GAM531_DPS931 eMail All]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107128DPS915/CodeKirin2014-12-06T01:20:31Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time, but the value is still correct. <br />
<br />
'''Approach'''<br />
<br />
Instead of doing everything within the main, I created a separate function for it. All the random number generating is done within the kernel via the Curand command. The kernel is also responsible for all the calculations and uses shared memory for all the threads within the block in order to obtain a partial sum. Here are some snippets of the code.<br />
<br />
''' Some Code Snippets '''<br />
<br />
If the dot is within the circle, sets the tid (threadIdx.x) index of the temp array in shared memory to 1 and sync the threads. Then sum up all the 1s in the temp array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels by using a for loop through all the indexes and adding the values together. This total sum is then used to calculate the value of pi.<br />
<br />
[[File:Code2.JPG]]<br />
<br />
'''Execution Times for Values of 1, 5 and 8 Million'''<br />
<br />
[[File:reportTime.JPG]]<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
'''Issues'''<br />
<br />
The main issue for me was to figure out how to use the kernel for this approach. At first I tried to pass a value of either 1 or 0 for whether or not the dot landed within the circle within each thread, and pass it out into an array individually. Later on Chris gave me the idea of getting a partial sum for all the threads within each block and pass that out instead, which is a way better approach. <br />
<br />
Another big issue was the crashing of the graphic driver. If the program takes more than 3 seconds to execute, the driver would crash. Even when I changed the registry to allow 15 seconds before crashing, it still crashes at 3.<br />
<br />
For optimization, I tried using reduction, however it didn't seem to speed up the program.<br />
<br />
<br />
'''Different Approach'''<br />
<br />
Another approach to do this is by using a different algorithm, as the one I used at first. However, that program will only go up to 9 significant digits, since anything over will go above the maximum value of a float. This program shows an execution time of 0.05 seconds for all values entered by the user, but will require to use the BigNumber library or such in order to show more significant digits.</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:ReportTime.JPG&diff=107127File:ReportTime.JPG2014-12-06T01:18:26Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107126DPS915/CodeKirin2014-12-06T01:18:11Z<p>Tqyu: /* Assignment 2 and 3 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time, but the value is still correct. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Approach'''<br />
<br />
Instead of doing everything within the main, I created a separate function for it. All the random number generating is done within the kernel via the Curand command. The kernel is also responsible for all the calculations and uses shared memory for all the threads within the block in order to obtain a partial sum. Here are some snippets of the code.<br />
<br />
''' Some Code Snippets '''<br />
<br />
If the dot is within the circle, sets the tid (threadIdx.x) index of the temp array in shared memory to 1 and sync the threads. Then sum up all the 1s in the temp array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels by using a for loop through all the indexes and adding the values together. This total sum is then used to calculate the value of pi.<br />
<br />
[[File:Code2.JPG]]<br />
<br />
'''Execution Times for Values of 1, 5 and 8 Million'''<br />
<br />
[[File:reportTime.JPG]]<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
'''Issues'''<br />
<br />
The main issue for me was to figure out how to use the kernel for this approach. At first I tried to pass a value of either 1 or 0 for whether or not the dot landed within the circle within each thread, and pass it out into an array individually. Later on Chris gave me the idea of getting a partial sum for all the threads within each block and pass that out instead, which is a way better approach. <br />
<br />
Another big issue was the crashing of the graphic driver. If the program takes more than 3 seconds to execute, the driver would crash. Even when I changed the registry to allow 15 seconds before crashing, it still crashes at 3.<br />
<br />
For optimization, I tried using reduction, however it didn't seem to speed up the program.<br />
<br />
<br />
'''Different Approach'''<br />
<br />
Another approach to do this is by using a different algorithm, as the one I used at first. However, that program will only go up to 9 significant digits, since anything over will go above the maximum value of a float. This program shows an execution time of 0.05 seconds for all values entered by the user, but will require to use the BigNumber library or such in order to show more significant digits.</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107077DPS915/CodeKirin2014-12-04T14:21:00Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time, but the value is still correct. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Approach'''<br />
<br />
Instead of doing everything within the main, I created a separate function for it. All the random number generating is done within the kernel via the Curand command. The kernel is also responsible for all the calculations and uses shared memory for all the threads within the block in order to obtain a partial sum. Here are some snippets of the code.<br />
<br />
''' Some Code Snippets '''<br />
<br />
If the dot is within the circle, sets the tid (threadIdx.x) index of the temp array in shared memory to 1 and sync the threads. Then sum up all the 1s in the temp array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels by using a for loop through all the indexes and adding the values together. This total sum is then used to calculate the value of pi.<br />
<br />
[[File:Code2.JPG]]<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
'''Issues'''<br />
<br />
The main issue for me was to figure out how to use the kernel for this approach. At first I tried to pass a value of either 1 or 0 for whether or not the dot landed within the circle within each thread, and pass it out into an array individually. Later on Chris gave me the idea of getting a partial sum for all the threads within each block and pass that out instead, which is a way better approach. <br />
<br />
Another big issue was the crashing of the graphic driver. If the program takes more than 3 seconds to execute, the driver would crash. Even when I changed the registry to allow 15 seconds before crashing, it still crashes at 3.<br />
<br />
For optimization, I tried using reduction, however it didn't seem to speed up the program.<br />
<br />
<br />
'''Different Approach'''<br />
<br />
Another approach to do this is by using a different algorithm, as the one I used at first. However, that program will only go up to 9 significant digits, since anything over will go above the maximum value of a float. This program shows an execution time of 0.05 seconds for all values entered by the user, but will require to use the BigNumber library or such in order to show more significant digits.</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107076DPS915/CodeKirin2014-12-04T14:08:30Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time, but the value is still correct. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Approach'''<br />
<br />
Instead of doing everything within the main, I created a separate function for it. All the random number generating is done within the kernel via the Curand command. The kernel is also responsible for all the calculations and uses shared memory for all the threads within the block in order to obtain a partial sum. Here are some snippets of the code.<br />
<br />
''' Some Code Snippets '''<br />
<br />
If the dot is within the circle, sets the tid (threadIdx.x) index of the temp array in shared memory to 1 and sync the threads. Then sum up all the 1s in the temp array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels by using a for loop through all the indexes and adding the values together. This total sum is then used to calculate the value of pi.<br />
<br />
[[File:Code2.JPG]]<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
'''Issues'''<br />
<br />
The main issue for me was to figure out how to use the kernel for this approach. At first I tried to pass a value of either 1 or 0 for whether or not the dot landed within the circle within each thread, and pass it out into an array individually. Later on Chris gave me the idea of getting a partial sum for all the threads within each block and pass that out instead, which is a way better approach. <br />
<br />
Another big issue was the crashing of the graphic driver. If the program takes more than 3 seconds to execute, the driver would crash. Even when I changed the registry to allow 15 seconds before crashing, it still crashes at 3.<br />
<br />
For optimization, I tried using reduction, however it didn't seem to speed up the program.</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107075DPS915/CodeKirin2014-12-04T13:52:32Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time, but the value is still correct. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Approach'''<br />
<br />
Instead of doing everything within the main, I created a separate function for it. All the random number generating is done within the kernel via the Curand command. The kernel is also responsible for all the calculations and uses shared memory for all the threads within the block in order to obtain a partial sum. Here are some snippets of the code.<br />
<br />
''' Some Code Snippets '''<br />
<br />
If the dot is within the circle, sets the tid (threadIdx.x) index of the temp array in shared memory to 1 and sync the threads. Then sum up all the 1s in the temp array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels by using a for loop through all the indexes and adding the values together. This total sum is then used to calculate the value of pi.<br />
<br />
[[File:Code2.JPG]]<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
'''Issues'''<br />
<br />
The main issue for me was to figure out how to use the kernel for this approach. At first I tried to pass a value of either 1 or 0 for whether or not the dot landed within the circle within each thread, and pass it out into an array individually. Later on Chris gave me the idea of getting a partial sum for all the threads within each block and pass that out instead, which is a way better approach. <br />
<br />
For optimization, I tried using reduction, however it didn't seem to speed up the program.</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107074DPS915/CodeKirin2014-12-04T13:35:36Z<p>Tqyu: /* Assignment 2 and 3 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Approach'''<br />
<br />
Instead of doing everything within the main, I created a separate function for it. All the random number generating is done within the kernel via the Curand command. The kernel is also responsible for all the calculations and uses shared memory for all the threads within the block in order to obtain a partial sum. Here are some snippets of the code.<br />
<br />
''' Some Code Snippets '''<br />
<br />
If the dot is within the circle, sets the tid (threadIdx.x) index of the temp array in shared memory to 1 and sync the threads. Then sum up all the 1s in the temp array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels by using a for loop through all the indexes and adding the values together. This total sum is then used to calculate the value of pi.<br />
<br />
[[File:Code2.JPG]]<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
'''Issues'''<br />
<br />
The main issue for me was to figure out how to use the kernel for this approach. At first I tried to pass a value of either 1 or 0 for whether or not the dot landed within the circle within each thread, and pass it out into an array individually. Later on Chris gave me the idea of getting a partial sum for all the threads within each block and pass that out instead, which is a way better approach. <br />
<br />
For optimization, I tried using reduction, however it didn't seem to speed up the program.</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107073DPS915/CodeKirin2014-12-04T13:26:24Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Approach'''<br />
<br />
Instead of doing everything within the main, I created a separate function for it. All the random number generating is done within the kernel via the Curand command. The kernel is also responsible for all the calculations and uses shared memory for all the threads within the block in order to obtain a partial sum. Here are some snippets of the code.<br />
<br />
''' Some Code Snippets '''<br />
<br />
If the dot is within the circle, sets the tid (threadIdx.x) index of the temp array in shared memory to 1 and sync the threads. Then sum up all the 1s in the temp array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels by using a for loop through all the indexes and adding the values together. This total sum is then used to calculate the value of pi.<br />
<br />
[[File:Code2.JPG]]<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107071DPS915/CodeKirin2014-12-04T13:07:33Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
<br />
''' Some Code Snippets '''<br />
<br />
Sets the tid (threadIdx.x) index of the temp array in shared memory to 1, when the total <= 1.0, and sync the threads. Then sum up all the 1s in the array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels and calculates the value of pi.<br />
<br />
[[File:Code2.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107070DPS915/CodeKirin2014-12-04T13:07:12Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
======<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
<br />
''' Some Code Snippets '''<br />
<br />
Sets the tid (threadIdx.x) index of the temp array in shared memory to 1, when the total <= 1.0, and sync the threads. Then sum up all the 1s in the array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels and calculates the value of pi.<br />
<br />
[[File:Code2.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107069DPS915/CodeKirin2014-12-04T13:06:49Z<p>Tqyu: /* Assignment 1 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
<br />
''' Some Code Snippets '''<br />
<br />
Sets the tid (threadIdx.x) index of the temp array in shared memory to 1, when the total <= 1.0, and sync the threads. Then sum up all the 1s in the array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels and calculates the value of pi.<br />
<br />
[[File:Code2.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107068DPS915/CodeKirin2014-12-04T13:06:30Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Brief Overview'''<br />
<br />
Monte Carlo approach to calculating Pi involves a circle on top of a square. Dots will be randomly drawn onto the square, and by adding up all the dots that landed within the circle then dividing by 4, will get you a value close to Pi. The more dots drawn, the more accurate Pi will become.<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
<br />
''' Some Code Snippets '''<br />
<br />
Sets the tid (threadIdx.x) index of the temp array in shared memory to 1, when the total <= 1.0, and sync the threads. Then sum up all the 1s in the array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels and calculates the value of pi.<br />
<br />
[[File:Code2.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Code2.JPG&diff=107046File:Code2.JPG2014-12-03T21:50:11Z<p>Tqyu: uploaded a new version of "File:Code2.JPG"</p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Code2.JPG&diff=107045File:Code2.JPG2014-12-03T21:48:55Z<p>Tqyu: uploaded a new version of "File:Code2.JPG":&#32;Reverted to version as of 21:46, 3 December 2014</p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Code2.JPG&diff=107044File:Code2.JPG2014-12-03T21:48:15Z<p>Tqyu: uploaded a new version of "File:Code2.JPG"</p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Code1.JPG&diff=107043File:Code1.JPG2014-12-03T21:47:31Z<p>Tqyu: uploaded a new version of "File:Code1.JPG"</p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Code2.JPG&diff=107042File:Code2.JPG2014-12-03T21:46:17Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Code1.JPG&diff=107041File:Code1.JPG2014-12-03T21:46:08Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107040DPS915/CodeKirin2014-12-03T21:45:54Z<p>Tqyu: /* Assignment 2 and 3 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]<br />
<br />
<br />
<br />
''' Some Code Snippets '''<br />
<br />
Sets the tid (threadIdx.x) index of the temp array in shared memory to 1, when the total <= 1.0, and sync the threads. Then sum up all the 1s in the array for that specific block and pass it out into another array.<br />
<br />
[[File:Code1.JPG]]<br />
<br />
After copying from the device to host, obtain the total sum of results from all kernels and calculates the value of pi.<br />
<br />
[[File:Code2.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107039DPS915/CodeKirin2014-12-03T21:36:24Z<p>Tqyu: /* Assignment 2 and 3 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time. The Nvidia Visual Profiler doesn't work either, it gets stuck on generating timeline, so I used clock_t in the code instead in order to calculate execution time of the kernel. Don't think this is 100% accurate though.<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:ChartMonteCarlo.JPG&diff=107038File:ChartMonteCarlo.JPG2014-12-03T21:34:51Z<p>Tqyu: uploaded a new version of "File:ChartMonteCarlo.JPG"</p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:8MillionMonteCarlo.JPG&diff=107037File:8MillionMonteCarlo.JPG2014-12-03T21:17:36Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107036DPS915/CodeKirin2014-12-03T21:17:28Z<p>Tqyu: /* Assignment 2 and 3 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time.<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 8 Million'''<br />
<br />
[[File:8MillionMonteCarlo.JPG]]<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:5MillionMonteCarlo.JPG&diff=107035File:5MillionMonteCarlo.JPG2014-12-03T21:16:53Z<p>Tqyu: uploaded a new version of "File:5MillionMonteCarlo.JPG"</p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:MillionMonteCarlo.JPG&diff=107034File:MillionMonteCarlo.JPG2014-12-03T21:16:05Z<p>Tqyu: uploaded a new version of "File:MillionMonteCarlo.JPG"</p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107033DPS915/CodeKirin2014-12-03T20:43:00Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time.<br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
'''Value of 5 Million'''<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
'''Comparison Chart'''<br />
<br />
[[File:ChartMonteCarlo.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:5MillionMonteCarlo.JPG&diff=107032File:5MillionMonteCarlo.JPG2014-12-03T20:42:19Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:MillionMonteCarlo.JPG&diff=107031File:MillionMonteCarlo.JPG2014-12-03T20:42:08Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107030DPS915/CodeKirin2014-12-03T20:42:01Z<p>Tqyu: /* Assignment 2 and 3 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes most of the time.<br />
<br />
[[File:MillionMonteCarlo.JPG]]<br />
<br />
[[File:5MillionMonteCarlo.JPG]]<br />
<br />
[[File:ChartMonteCarlo.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107029DPS915/CodeKirin2014-12-03T20:38:43Z<p>Tqyu: /* Assignment 2 and 3 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes half the time.<br />
<br />
[[File:ChartMonteCarlo.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107028DPS915/CodeKirin2014-12-03T20:38:30Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
<br />
'''(Note)'''<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes half the time.<br />
<br />
[[File:ChartMonteCarlo.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107027DPS915/CodeKirin2014-12-03T20:37:54Z<p>Tqyu: /* Assignment 2 and 3 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
'''(Note)'''<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes half the time.<br />
<br />
[[File:ChartMonteCarlo.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:ChartMonteCarlo.JPG&diff=107026File:ChartMonteCarlo.JPG2014-12-03T20:37:30Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107025DPS915/CodeKirin2014-12-03T20:36:45Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
'''(Note)'''<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes half the time.<br />
<br />
[[File:Chart.JPG]]</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107020DPS915/CodeKirin2014-12-03T20:04:40Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed. <br />
'''(Note)'''<br />
For some reason the code crashes my graphic driver past 8000000 (8 million) dots, and even at 8 million it crashes half the time.</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=107018DPS915/CodeKirin2014-12-03T19:22:10Z<p>Tqyu: /* Calculations of Pi */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 and 3 ===<br />
I have combined the 2nd and 3rd part of the assignment together, since I had some issues with the kernel. <br />
<br />
The following results compares the upgraded code with the original to show a significant increase in speed.</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=GPU610/DPS915_G_P_Index_20143&diff=106923GPU610/DPS915 G P Index 201432014-11-26T14:48:54Z<p>Tqyu: /* Presentation Schedule */</p>
<hr />
<div>{{GPU610/DPS915 Index | 20143}}<br />
<br />
Please add an overview of your group here and create a separate project page for your group!<br />
<br />
= Group and Project Index =<br />
<br />
You can find a sample project page template [[GPU610/DPS915_Sample_Project_Page | here]]<br />
<br />
<!--<br />
== [[GPU610/DPS915 Sample Project Page| Group Name]] ==<br />
'''Project Name'''<br />
# [mailto:chris.szalwinski@senecacollege.ca?subject=gpu610 Chris Szalwinski]<br />
# [mailto:chris.szalwinski@senecacollege.ca?subject=gpu610 Chris Szalwinski]<br />
[mailto:chris.szalwinski@senecacollege.ca,fardad.soleimanloo@senecacollege.ca?subject=gpu610 eMail All]<br />
--><br />
<br />
== [[AAA_Adrina_Arsa_Andriy | AAA]] ==<br />
# [mailto:aasauvageot@myseneca.ca?subject=gpu610 Adrian Sauvageot]<br />
# [mailto:gandriy1@myseneca.ca?subject=dps915 Andriy Guzenko]<br />
# [mailto:akhalid19@myseneca.ca?subject=dps915 Arsalan Khalid]<br />
[mailto:aasauvageot@myseneca.ca,gandriy1@myseneca.ca,akhalid19@myseneca.ca?subject=dps915, Email All]<br />
<br />
== [[Hu3Team| Hu3]] ==<br />
# [mailto:bdigiuseppecardosode@myseneca.ca?subject=gpu610 Bruno Di Giuseppe]<br />
# [mailto:chdeandradesilva@myseneca.ca?subject=gpu610 Carlos Silva]<br />
[mailto:bdigiuseppecardosode@myseneca.ca;chdeandradesilva@myseneca.ca?subject=dps901-gpu610 Email All]<br />
<br />
==[[TeamC| TeamC]] ==<br />
# [mailto:cchoi12@myseneca.ca?subject=GPU610 Chiyoung Choi]<br />
[mailto:cchoi12@myseneca.ca?subject=GPU610 eMail All]<br />
<br />
== [[DPS915/CodeCookers| CodeCookers]] ==<br />
'''Project Name'''<br />
# [mailto:wchamilton@myseneca.ca?subject=dps915 Wesley Hamilton] <br />
# [mailto:ncuriciac@myseneca.ca?subject=dps915 Norbert Curiciac]<br />
# [mailto:rlanderson@myseneca.ca@myseneca.ca?subject=dps915 Rene Leon Anderson]<br />
[mailto:wchamilton@myseneca.ca;ncuriciac@myseneca.ca;rlanderson@myseneca.ca@myseneca.ca?subject=DPS915 eMail All]<br />
<br />
== [[GPU610/TeamKCM| Team KCM]] ==<br />
'''Project Name'''<br />
# [mailto:bkim35@myseneca.ca?subject=gpu610 Byungho Kim]<br />
# [mailto:tchung22@myseneca.ca?subject=gpu610 Taeyang Chung]<br />
# [mailto:symoon@myseneca.ca?subject=gpu610 SeungYeon Moon]<br />
[mailto:bkim35@myseneca.ca;tchung22@myseneca.ca;symoon@myseneca.ca?subject=GPU610 eMail All]<br />
<br />
== [[GPU610/TeamEh| TeamEh]] ==<br />
'''Project Name'''<br />
# [mailto:bssnively@myseneca.ca?subject=gpu610 Benjamin Snively]<br />
# [mailto:bhoover1@myseneca.ca?subject=gpu610 Brad Hoover]<br />
# [mailto:bczunyi@myseneca.ca?subject=gpu610 Bailint Czunyi]<br />
[mailto:bssnively@myseneca.ca;bhoover1@myseneca.ca;bczunyi@myseneca.ca?subject=GPU610 eMail All]<br />
<br />
== [[GPU610/Team AGC| Team AGC]] ==<br />
'''Project Name'''<br />
# [mailto:acooc@myseneca.ca?subject=gpu610 Andy Cooc], Some responsibility<br />
# [mailto:gcastrolondono@myseneca.ca?subject=gpu610 Gabriel Castro], Some other responsibility<br />
# [mailto:cmarkieta@myseneca.ca?subject=gpu610 Christopher Markieta], Some other responsibility<br />
[mailto:acooc@myseneca.ca,gcastrolondono@myseneca.ca,cmarkieta@myseneca.ca?subject=gpu610 Email All]<br />
<br />
== [[GPU610/TeamHCE| Team HCE]] ==<br />
'''MD5's Last Stand'''<br />
# [mailto:bdhenderson@myseneca.ca?subject=gpu610 Brendan Henderson]<br />
[mailto:bdhenderson@myseneca.ca?subject=GPU610 eMail All]<br />
<br />
== [[DPS915/CodeKirin| CodeKirin]] ==<br />
'''Calculations of Pi'''<br />
# [mailto:tqyu@myseneca.ca?subject=dps915 Tony Yu]<br />
[mailto:tqyu@myseneca.ca?subject=dps915 eMail All]<br />
<br />
== [[Skynet/GPU610| Skynet]] ==<br />
'''Ray Tracer'''<br />
# [mailto:mmwang2@myseneca.ca?subject=gpu610 Michael Wang]<br />
# [mailto:bpereira5@myseneca.ca?subject=gpu610 Bruno Pereira]<br />
[mailto:mmwang2@myseneca.ca;bpereira5@myseneca.ca?subject=gpu610 Email All]<br />
<br />
== Presentation Schedule ==<br />
<br />
{| border="1"<br />
|-<br />
|Team Name<br />
|Date and Time<br />
|-<br />
|Team Eh<br />
|Thursday 8:00<br />
|-<br />
|<br />
|...<br />
|-<br />
|-<br />
|Group AAA<br />
|Thursday 8:30<br />
|-<br />
|CodeKirin<br />
|Thursday 8:45<br />
|-<br />
|Group CodeCookers<br />
|Thursday 9:00<br />
|-<br />
|SkyNet<br />
|Thursday 9:15<br />
|-<br />
|TeamAGC<br />
|Thursday 9:30<br />
<br />
|}<br />
<br />
<br /></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=106612DPS915/CodeKirin2014-10-30T20:09:44Z<p>Tqyu: /* Assignment 1 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
'''Value of 10 Million'''<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
'''Value of 100 Million'''<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
'''Value of 1 Billion'''<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 ===<br />
=== Assignment 3 ===</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=106611DPS915/CodeKirin2014-10-30T20:09:27Z<p>Tqyu: /* Progress */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
'''Value of 1 Million'''<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
Value of 10 Million<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
Value of 100 Million<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
Value of 1 Billion<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 ===<br />
=== Assignment 3 ===</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Profile_a1(billion).JPG&diff=106610File:Profile a1(billion).JPG2014-10-30T20:08:53Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Profile_a1(100_million).JPG&diff=106609File:Profile a1(100 million).JPG2014-10-30T20:08:46Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Profile_a1(10_million).JPG&diff=106608File:Profile a1(10 million).JPG2014-10-30T20:08:30Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=106607DPS915/CodeKirin2014-10-30T20:07:13Z<p>Tqyu: /* Assignment 1 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
Value of 1 Million<br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
Value of 10 Million<br />
<br />
[[File:Profile_a1(10 million).JPG]]<br />
<br />
Value of 100 Million<br />
<br />
[[File:Profile_a1(100 million).JPG]]<br />
<br />
Value of 1 Billion<br />
<br />
[[File:Profile_a1(billion).JPG]]<br />
<br />
=== Assignment 2 ===<br />
=== Assignment 3 ===</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Profile_a1(million).JPG&diff=106606File:Profile a1(million).JPG2014-10-30T20:06:21Z<p>Tqyu: uploaded a new version of "File:Profile a1(million).JPG"</p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=File:Profile_a1(million).JPG&diff=106605File:Profile a1(million).JPG2014-10-30T20:03:43Z<p>Tqyu: </p>
<hr />
<div></div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=106604DPS915/CodeKirin2014-10-30T20:02:53Z<p>Tqyu: /* Assignment 1 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
[[File:Profile_a1(million).JPG]]<br />
<br />
=== Assignment 2 ===<br />
=== Assignment 3 ===</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=106603DPS915/CodeKirin2014-10-30T19:50:19Z<p>Tqyu: /* Assignment 1 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
<s>The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.</s><br />
<br />
'''(Updated)'''<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
This program will calculate pi using the Monte Carlo approach to a precision based on the value entered by the user. <br />
<br />
[[File:Profile_a1.JPG]]<br />
<br />
=== Assignment 2 ===<br />
=== Assignment 3 ===</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=DPS915/CodeKirin&diff=106602DPS915/CodeKirin2014-10-30T19:49:15Z<p>Tqyu: /* Assignment 1 */</p>
<hr />
<div>= Calculations of Pi =<br />
== Team Member == <br />
# [mailto:tqyu@senecacollege.ca?subject=dps915 Tony Yu]<br />
<br />
== Progress ==<br />
=== Assignment 1 ===<br />
<br />
'''Findings'''<br />
<br />
The code used is taken from the following site http://www.cplusplus.com/forum/beginner/1149/ with some changes to the code.<br />
<br />
This program will calculate pi to a precision based on the value entered by the user. Currently it displays to a precision of 9 decimal places.<br />
<br />
Will attempt to figure out a way to calculate to as much decimal places as possible, which should drastically increase the time it takes to run the program. Currrent possible solution is to use the BigNumber library.<br />
<br />
(Updated)<br />
<br />
The code used is taken from the following site https://helloacm.com/cc-coding-exercise-finding-approximation-of-pi-using-monto-carlo-algorithm/ with some changes to it.<br />
<br />
[[File:Profile_a1.JPG]]<br />
<br />
=== Assignment 2 ===<br />
=== Assignment 3 ===</div>Tqyuhttps://wiki.cdot.senecacollege.ca/w/index.php?title=GAM531/DPS931Student_List_20143&diff=106411GAM531/DPS931Student List 201432014-10-09T13:58:54Z<p>Tqyu: /* Student List */</p>
<hr />
<div><big><big> Game Engine Foundations</big></big><br /><br />
{{GAM531/DPS931 Index | 20143}}<br />
<br />
Please add your information to the student list below!<br />
<br />
== Student List ==<br />
Insert the following at the end of the table (if you are a student in GAM531/DPS931).<br /><br />
<big><pre>|[[User:WN | FN]] ||LN|| [[PN |GN]] ||SB|| [mailto:ID@myseneca.ca?subject=SB ID]<br />
|-</pre></big><br />
Replace the following with your own information: <br /><br />
* WN: Your Wiki User name<br />
* FN: Your First Name<br />
* LN: Your Last Name<br />
* PN: Your Group's Project Page Name on the wiki<br />
* GN: Your Group name<br />
* SB: Your Subject (example: GAM531 or DPS931)<br />
* ID: Your email ID (myseneca id)<br />
* BB: Your bitbucket account<br />
<br />
<br />
{| class="wikitable sortable" border="1" cellpadding="5"<br />
|+ GAM531/DPS931 - Student List<br />
! First Name !! Last Name !! Team Name !! Subject !! Seneca Id !! Bit Bucket<br />
|-<br />
|[[User:CloudScorpion | Joseph]]||Hughes||[[GAM531/DPS931 Sample Team Page|Team Name]]||GAM531||[mailto:jp.hughes@senecacollege.ca?subject=gam531 jp.hughes] || [https://bitbucket.org/LSS_CloudScorpion/ LSS_CloudScorpion]<br />
|-<br />
|[[User:Chris Szalwinski | Chris]]||Szalwinski||[[GAM531/DPS931 Sample Team Page|Team Name]]||DPS931||[mailto:chris.szalwinski@senecacollege.ca?subject=dps931 chris.szalwinski] || [https://bitbucket.org/cszalwinski cszalwinski]<br />
|-<br />
|[[User:Boris Njike | Boris]]||Njike||[[GAM531/DPS931 Sample Team Page|Team Name]]||GAM531||[mailto:bmnjikeleugue@myseneca.ca?subject=gam531 boris.njike] || [https://bitbucket.org/BorisNjike BorisNjike]<br />
|-<br />
|[[User:Lucian Raymond Blaga | Raymond]]||Blaga||[[GAM531/DPS931 Sample Team Page|Team RECursion]]||GAM531||[mailto:rrblaga@senecacollege.ca?subject=gam531 rrblaga] || [https://bitbucket.org/teh_kriegerer/ teh_kriegerer]<br />
|-<br />
|[[User:Elliot Kwan| Elliot]]||Kwan||[[GAM531/DPS931 Sample Team Page|Team RECursion]]||GAM531||[mailto:ekwan10@myseneca.ca?subject=gam531 ekwan10] || [https://bitbucket.org/ElliotKwan ElliotKwan]<br />
|-<br />
|[[User:Christopher Markieta | Christopher]]||Markieta||[[GAM531/DPS931 Sample Team Page|Team RECursion]]||GAM531||[mailto:cmarkieta@myseneca.ca?subject=gam531 cmarkieta] || [https://bitbucket.org/ChrisMarkieta ChrisMarkieta]<br />
|-<br />
|[[User:Bradly Hoover | Brad]]||Hoover||[[GAM531/Team Slice|Team Slice]]||GAM531||[mailto:bhoover1@myseneca?subject=gam531 bhoover1] || [https://bitbucket.org/BradHoov BradHoov]<br />
|-<br />
|[[User:Balint Czunyi | Balint]]||Czunyi||[[GAM531/Team Slice|Team Slice]]||GAM531||[mailto:bczunyi@myseneca?subject=gam531 bczunyi] || [https://bitbucket.org/bczunyi bczunyi]<br />
|-<br />
|[[User:Nick Ramkay | Nick]]||Ramkay||[[GAM531/Team Slice|Team Slice]]||GAM531||[mailto:nramkay@myseneca?subject=gam531 nramkay] || [https://bitbucket.org/yakmar yakmar]<br />
|-<br />
|[[User:Chiyoung Choi | Chiyoung]]||Choi||[[Team Page| TBD]]||GAM531||[mailto:cchoi12@senecacollege.ca?subject=GAM531 cchoi12] || [https://bitbucket.org/ssuduruk ssuduruk]<br />
|-<br />
|[[User:Jan Gabriel Ona | Jan]] ||Ona|| [[Team Page|TBD]] ||GAM531|| [mailto:jrona@myseneca.ca?subject=GAM531 jrona] || [https://bitbucket.org/ParadoxMeltdown ParadoxMeltdown]<br />
|-<br />
|[[User:xxx | xxx]] ||xxx|| [[GAM531/DPS931 Team xxx|Team xxx]] ||GAM531|| [mailto:xxx@myseneca.ca?subject=GAM531 xxx] || [https://bitbucket.org/xxx xxx]<br />
|-<br />
|[[User:dwandja | Davson]]||Wandja||[[GAM531/Team A|Team A]]||GAM531||[mailto:dwandja@senecacollege.ca?subject=gam531 dwandja] || [https://bitbucket.org/dwandja/ dwandja]<br />
|-<br />
|[[User:tqyu| Tony]]||Yu||[[DPS931/FL4T|FL4T]]||DPS931||[mailto:tqyu@senecacollege.ca?subject=gam531 tqyu] || [https://bitbucket.org/CodeKirin CodeKirin]<br />
|-<br />
|[[User:Justin Sean Wilkin| Justin]]||Wilkin||[[GAM531/Team A|Team A]]||GAM531||[mailto:jswilkin@senecacollege.ca?subject=gam531 jswilkin] || [https://bitbucket.org/xwilkinx XWILKINX]<br />
|-<br />
|[[User:Dmytro Rudeshko| Dmytro]]||Rudeshko||[[GAM531/Team A|Team A]]||GAM531||[mailto:drudeshko@senecacollege.ca?subject=gam531 drudeshko] || [https://bitbucket.org/rudeshko rudeshko]<br />
|-<br />
|[[User:Rlanderson |Rene]]||Anderson||[[GAM531/DPS931 Sample Team Page|Team Name]]||DPS931||[mailto:rlanderson@senecacollege.ca?subject=dps931 rlanderson] || [https://bitbucket.org/ReneA ReneA]<br />
|-<br />
|[[User:wchamilton |Wesley]]||Hamilton||[[GAM531/HeadCrab|HeadCrab]]||DPS931||[mailto:wchamilton@myseneca.ca?subject=dps931 wchamilton] || [https://bitbucket.org/wchamilton wchamilton]<br />
|-<br />
|[[User:Carlos Henrique De Andrade Silva | Carlos]] ||Silva|| [[GAM531/DPS931 Sample Team Page|Team Hu3]] ||GAM531|| [mailto:chdeandradesilva@myseneca.ca?subject=GAM531 chdeandradesilva] || [https://bitbucket.org/henriquedeandrade henriquedeandrade]<br />
|-<br />
|[[User:Renato Fontel de Andrade | Renato]] ||de Andrade|| [[GAM531/DPS931 Sample Team Page|Team Hu3]] ||GAM531|| [mailto:rfonteldeandrade@myseneca.ca?subject=GAM531 rfonteldeandrade] || [https://bitbucket.org/rfonteldeandrade rfonteldeandrade]<br />
|-<br />
|[[User:Michael Mengyuan Wang | Michael]]|| Wang ||[[Skynet/GAM531|SkyNet]]||GAM531||[mailto:mmwang2@myseneca.ca?subject=gam531 mmwang2] || [https://bitbucket.org/mmwang2 mmwang2]<br />
|-<br />
|[[User:Bruno Pereira | Bruno]]|| Pereira ||[[Skynet/GAM531|SkyNet]]||GAM531||[mailto:bpereira5@myseneca.ca?subject=gam531 bpereira5] || [https://bitbucket.org/bpereira5 bpereira5]<br />
|-<br />
|[[User:Karina Cristina Sayuri Nishimura | Karina]]|| Nishimura ||[[GAM531/Brazuca|Brazuca]]||GAM531||[mailto:kcsayurinishimura@myseneca.ca?subject=gam531 kcsayurinishimura] || [https://bitbucket.org/karinanishimura karinanishimura]<br />
|-<br />
|[[User:Bruno Di Giuseppe Cardoso de Carvalh | Bruno]]|| Di Giuseppe ||[[GAM531/Brazuca|Brazuca]]||GAM531||[mailto:bdigiuseppecardosode@myseneca.ca?subject=gam531 bdigiuseppecardosdoe] || [https://bitbucket.org/bgcc bgcc]<br />
|-<br />
|[[User:Matthew R Tait | Matthew]]|| Tait||[[GAM531/DPS931 Sample Team Page|Team Name]]||DPS931||[mailto:mrtait1@myseneca.ca?subject=dps931 mrtait1] || [https://bitbucket.org/mrtait1 mrtait1]<br />
|-<br />
|[[User:svaghei|Shayan]]||Vaghei||[[DPS931/GoodName|GoodName]]||DPS931||[mailto:svaghei@myseneca.ca?subject=dps931 svaghei] || [https://bitbucket.org/wchamilton shayanvaghei]<br />
|-<br />
|[[User:yuzhixing| yuzhi]]||xing||[[GAM531/DPS931 Sample Team Page|Team Name]]||GAM531||[mailto:yxing5@senecacollege.ca?subject=gam531 yxing5] || [https://bitbucket.org/yuzhixing/ yuzhixing]<br />
|-<br />
|[[User:Jordan Terrance Wieb | Jordan]] ||Wieb|| [[DPS931/GoodName|GoodName]] ||DPS931|| [mailto:jtwieb@myseneca.ca?subject=DPS931 jtwieb] || [https://bitbucket.org/sizdian sizdian] <br />
|-<br />
|[[User:Ruslan Yurash | Ruslan]] ||Yurash|| [[Team Page|TBD]] ||GAM531|| [mailto:ryurash@myseneca.ca?subject=GAM531 ryurash] || [https://bitbucket.org/ruslanjur ruslanjur] <br />
|-</div>Tqyu