This tutorial is a high level overview of RPN notation, calculation of constants like π, displaying calculation results, and scaling the calculation to larger sizes.
User input is color highlighted in
Navigate to the project folder.
To run the program, type:
~/dev/calc-pi-x86-64-asm$./calc-pi (some stuff omitted) Accuracy: 60 Digits XREG 0.0 YREG 0.0 ZREG 0.0 TREG 0.0 (Elapsed time: 0 Seconds 00:00:00)Op Code:
RPN notation uses a register stack. The stack contains 4 registers X, Y, Z and T. Number input will place the value into the X register. The previous contents are pushed up the stack: X → Y → Z → T. Basic math operations will operate on the bottom of the stack acting on X and Y. The stack is rotated down: Y ← Z ← T.
In this example we will calculate ((4 * 5) / 2).
First, the base-10 conversion shall be set to
Number input is completed by pressing the keyboard Enter key.
Entering
(Elapsed time: 0 Seconds 00:00:00) Op Code:int XREG 0 YREG 0 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00) Op Code:4 XREG+4 YREG 0 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00) Op Code:5 XREG+5 YREG +4 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00) Op Code:* XREG+20 YREG 0 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00) Op Code:2 XREG+2 YREG +20 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00) Op Code:/ XREG+10 YREG 0 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00)Op Code:
The program contains a list of sub-programs to calculate math constants.
A list can be found here.
The command parser can accept text commands between 1 and 7 characters.
The command to calculate pi is "c.pi".
You will notice program output is still set to "int" mode
and the X register still contains "10" from the last example
Entering
XREG +10 YREG 0 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00) Op Code:clrall All Varaibles Cleared. XREG0 YREG 0 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00) Op Code:sigfigs 500 Accuracy: 500 Digits (Elapsed time: 0 Seconds 00:00:00) Op Code:c.pi Functon_calc_pi_chud: Calculation of pi using Chudnovsky formula. Calculation square root 10005 XREG+3 YREG 0 ZREG 0 TREG 0 (Elapsed time: 0 Seconds 00:00:00) Op Code: print+3 (Elapsed time: 0s Seconds 00:00:00)Op Code:
You will notice that the result for π was "3" showing only 1 digit of accuracy. This is because the base-10 converter is still set to integer mode ("int" mode).
All numbers are stored binary floating point format.
In order to view the numbers in human understandable output,
it is necessary to convert the binary numbers (base-2) to
recognizable (base-10) format. The base-10 conversion can be
set to 3 modes: fix, int or sci. The program is currently in "int" mode.
Change the base-10 conversion to scientific notation by entering
(Elapsed time: 0 Seconds 00:00:00) Op Code:sci XREG+3.14159265358979323846264338327950288419716939937510 E+0 YREG 0.0 ZREG 0.0 TREG 0.0 (Elapsed time: 0 Seconds 00:00:00) Op Code:+3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865<PHONE_NUMBER>709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612<PHONE_NUMBER>786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962<PHONE_NUMBER>153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051<PHONE_NUMBER>237996274956735188575272489122793818301194912 E+0 (Elapsed time: 0 Seconds 00:00:00)Op Code:
You will notice the exponent value " E+0" is printed both on the abbreviated stack output
and in response to the print command. Next set the base-10 conversion to fix mode by
entering
(Elapsed time: 0 Seconds 00:00:00) Op Code:fix XREG+3.14159265358979323846264338327950288419716939937510 YREG 0.0 ZREG 0.0 TREG 0.0 (Elapsed time: 0 Seconds 00:00:00) Op Code:. +3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865<PHONE_NUMBER>709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593344612<PHONE_NUMBER>786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962<PHONE_NUMBER>153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051<PHONE_NUMBER>237996274956735188575272489122793818301194912 (Elapsed time: 0 Seconds 00:00:00)Op Code:
You will note the exponent has been removed from the output in "fix" mode. In summary, the program is set to internal accuracy of 500 digits. An internal sub-program was executed to calculate the constant π to 500 digits. We printed the result in "fix" notation.
In the previous example, the text output containing the number was a long string of number characters. When it reached the right side of my console window, the text wrapped to the next line. A smaller window would print something like this, however, it is still one single line of text 500 characters long.
+3.14159265358979323846264338327950288419716939937<PHONE_NUMBER>9445923078164062862089986280348253421170<PHONE_NUMBER>6513282306647093844609550582231725359408<PHONE_NUMBER>5028410270193852110555964462294895493038<PHONE_NUMBER>9756659334461284756482337867831652712019<PHONE_NUMBER>6923460348610454326648213393607260249141<PHONE_NUMBER>0660631558817488152092096282925409171536<PHONE_NUMBER>3600113305305488204665213841469519415116<PHONE_NUMBER>0365759591953092186117381932611793105118<PHONE_NUMBER>7996274956735188575272489122793818301194 912
The print command will accept a modifier. The letter "f" will specify text format
with number characters in groups of 10 characters separated by a space. These
will be set in lines of 100 characters, and for larger numbers, in blocks of 1000 characters.
Repeat the print command using the period character, but append "f" by entering
(Elapsed time: 0 Seconds 00:00:00) Op Code:. f +3.1415926535<PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER><PHONE_NUMBER> (Elapsed time: 0 Seconds 00:00:00)Op Code:
You will probably notice that calculation of π was very fast when the accuracy is limited to 500 digits. In order to increase the accuracy, two factors come into play: memory and time. The size of the variables in terms of number of bytes or number of 64 bit words will need to be increased. The arithmetic part of the program will take more time perform the math operations, in particular long division. The type of arithmetic performed in this program involves basic binary math such as multiplication and long division by rotation of binary bits left and right while subtracting or adding numbers. As variables get larger in size, the time needed for this type of arithmetic scales exponentially. Yes, this implies there is a practical upper limit. In the case of this program, the time limit is reached long before the memory limit.
Calculations can be scaled by trial and error. The accuracy can be increased in steps. The scale factor can be plotted in a spreadsheet by creating a "log-log" chart with the logarithm of the number of digits on the X axis and logarithm of the time in seconds on the Y axis. Here is an example of such a chart made in 2015 when I was first writing the program.
Let's try it. This time we will calculate the constant e with the command "c.e".
As seen above, we use
Enter
Enter
Enter
Enter
Enter
Please observe the time needed for the calculation at each step.
You will see the time increase exponentially.
(Elapsed time: 0 Seconds 00:00:00) Op Code:clrall All Varaibles Cleared. XREG 0.0 YREG 0.0 ZREG 0.0 TREG 0.0 (Elapsed time: 0 Seconds 00:00:00) Op Code:sf 10000 Accuracy: 10000 Digits (Elapsed time: 0 Seconds 00:00:00) Op Code:c.e Function_calc_e_Fix: Calculating e using sum 1/n! XREG +2.71828182845904523536028747135266249775724709369995 E+0 YREG 0.0 ZREG 0.0 TREG 0.0 (Elapsed time:0 Seconds 00:00:00 ) Op Code:sf 100000 Accuracy: 100000 Digits (Elapsed time: 0 Seconds 00:00:00) Op Code:c.e Function_calc_e_Fix: Calculating e using sum 1/n! XREG +2.71828182845904523536028747135266249775724709369995 E+0 YREG +2.71828182845904523536028747135266249775724709369995 E+0 ZREG 0.0 TREG 0.0 (Elapsed time:2 Seconds 00:00:02 ) Op Code:sf 200000 Accuracy: 200000 Digits (Elapsed time: 0 Seconds 00:00:00) Op Code:c.e Function_calc_e_Fix: Calculating e using sum 1/n! XREG +2.71828182845904523536028747135266249775724709369995 E+0 YREG +2.71828182845904523536028747135266249775724709369995 E+0 ZREG +2.71828182845904523536028747135266249775724709369995 E+0 TREG 0.0 (Elapsed time:6 Seconds 00:00:06 ) Op Code:sf 500000 Accuracy: 500000 Digits (Elapsed time: 0 Seconds 00:00:00) Op Code:c.e Function_calc_e_Fix: Calculating e using sum 1/n! XREG +2.71828182845904523536028747135266249775724709369995 E+0 YREG +2.71828182845904523536028747135266249775724709369995 E+0 ZREG +2.71828182845904523536028747135266249775724709369995 E+0 TREG +2.71828182845904523536028747135266249775724709369995 E+0 (Elapsed time:35 Seconds 00:00:35 ) Op Code:sf 1000000 Accuracy: 1000000 Digits (Elapsed time: 0 Seconds 00:00:00) Op Code:c.e Function_calc_e_Fix: Calculating e using sum 1/n! XREG +2.71828182845904523536028747135266249775724709369995 E+0 YREG +2.71828182845904523536028747135266249775724709369995 E+0 ZREG +2.71828182845904523536028747135266249775724709369995 E+0 TREG +2.71828182845904523536028747135266249775724709369995 E+0 (Elapsed time:133 Seconds 00:02:13 ) Op Code:
Here we are up to 1 million digits and the time for the calculation of e is 2 minutes 13 seconds.
Next, lets check how much memory we are using.
The "v" modifier can be added to the sigfigs or sf
command to show more verbose information on the
size of the variables. Please input
(Elapsed time: 133 Seconds 00:02:13) Op Code:sf v Decimal (base 10) Accuracy: Printed Digits: 1000000 (Configurable) Extended Digits: 0 (Shows extra digits) Useable Digits: 1000016 (Theoretical) Total Calc Digits: 1000093 (With Guard Words) Available Digits: 40403465 (Useable digits) Binary Accuracy: Mantissa Words: 51906 Words 415248 Bytes Guard Words: 4 Words 32 Bytes Total Words: 51910 Words415280 Bytes Exponent Size: 1 Words 8 Bytes Available Size: 2097152 Words16777216 Bytes (Elapsed time: 0 Seconds 00:00:00) Op Code:
You can see the program was compiled with about 16 MB allocated to each variable. At 1,000,000 digits, each variable is using about 4 MB of the maximum variable size, so we are using about 1/4 of the memory. Of course, the program can be recompiled with larger variables if you like.
Imagine you are trying a calculation that may take several days to complete. You start the program. You are waiting... and waiting... It would be nice to see some work in progress.
In the case of calculation of e, the terms added to the infinite series
get smaller as the calculation progresses. In this case, I have a feature that
can sample 4 bit nibbles across equally spaced parts of the mantissa and print
the mantissa nibbles using a term counter. In the case of this example, we
use the "sstep" command to set the step counter to show every 5000 steps with
the command
(Elapsed time: 0 Seconds 00:00:00) Op Code:sstep 5000 [iShowCalcStep] = 5000 (Elapsed time: 0 Seconds 00:00:00) Op Code:show Show Progress: On, Step = 5000 (Elapsed time: 0 Seconds 00:00:00) Op Code:c.e Function_calc_e_Fix: Calculating e using sum 1/n!  First, the time needed for each set of 5000 terms decreases starting at 6 seconds per 5000 terms, decreasing to less than 1 second per 5000 terms added to the infinite sum. Second, the "shift" number shows the number of words the mantissa must be shifted to add next term to the series sum. As the shift count approaches the word count, the accuracy of the factorial 1/n term may be decreased.
The progress bar functions must be embedded manually into a given infinite series. Therefore, not all calculations show the progress bar.
Well, there you have it. You just calculated the constant e to 1 million decimal places.
You can print it with


Lucas Santos
Wanna learn cool stuff?
Check out my latest posts below!
Lucas Santos, 20, Future Web Developer


SignIn Page
{{ wtf.quick_form(form,form_type='horizontal') }}
you do not have a account? please click here to create a account
{% extends "/base.html" %} {% import "bootstrap/wtf.html" as wtf %} {% block title %}Sign In Page{% endblock %} {% block content %}
you do not have a account? please click here to create a account


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.sun.syndication.io.impl;
18
19 import org.jdom.Document;
20 import org.jdom.Element;
21 import org.jdom.Namespace;
22 import com.sun.syndication.feed.WireFeed;
23
24
25 /***
26 * To address issue with certain feeds (brought up by Charles Miller):
27 *
28 * "During the debacle that was the rollout of RSS2.0, this namespace was tried,
29 * and even appeared in Dave Winer's Scripting News feed for a while. It was
30 * then withdrawn, but the wonderful thing about standards is the moment you
31 * roll one out, even if it's marked as unfinished and subject to change,
32 * someone will end up stuck with it forever."
33 *
34 * Note that there is not counter part on the generator, we only generate the final RSS2
35 *
36 */
37 public class RSS20wNSParser extends RSS20Parser {
38 private static String RSS20_URI = "http://backend.userland.com/rss2";
39
40 public RSS20wNSParser() {
41 this("rss_2.0wNS");
42 }
43
44 protected RSS20wNSParser(String type) {
45 super(type);
46 }
47
48 public boolean isMyType(Document document) {
49 Element rssRoot = document.getRootElement();
50 Namespace defaultNS = rssRoot.getNamespace();
51 boolean ok = defaultNS!=null && defaultNS.equals(getRSSNamespace());
52 if (ok) {
53 ok = super.isMyType(document);
54 }
55 return ok;
56 }
57
58 protected Namespace getRSSNamespace() {
59 return Namespace.getNamespace(RSS20_URI);
60 }
61
62 /***
63 * After we parse the feed we put "rss_2.0" in it (so converters and generators work)
64 * this parser is a phantom.
65 *
66 */
67 protected WireFeed parseChannel(Element rssRoot) {
68 WireFeed wFeed = super.parseChannel(rssRoot);
69 wFeed.setFeedType("rss_2.0");
70 return wFeed;
71 }
72
73 }


intro_slider 2.3.4
intro_slider: ^2.3.4 copied to clipboard
Flutter Intro Slider is a flutter plugin that helps you make a cool intro for your app
2.3.4 #
- Allow custom the physics horizontal scroll for the slide
slides
not require when usinglistCustomTabs
2.3.3 #
- Update scrollbar
2.3.2 #
- Add scrollbar for tab content
2.3.1 #
- Update example (migrate to AndroidX)
2.3.0 #
- Add isShowNextBtn
2.2.9 #
- Dispose tabController/animations.
2.2.8 #
- Allow supplying a custom title and/or description widgets.
2.2.7 #
- Set backgroundColor to Colors.amberAccent when not define
2.2.6 #
- Remove some unnecessary files
2.2.5 #
- Update docs
2.2.4 #
- Update docs
2.2.3 #
- Fix dot animation don't working properly on RTL language
2.2.2 #
- Add refFuncGoToTab, then we can move to any tab index programmatically
2.2.1 #
- Fix color dots displaced to the right on last slide
2.2.0 #
- Add more dots animation
2.1.1 #
- Add can set background color for all slides
- Add can hide DONE button
2.1.0 #
- Add animation when dot indicator is moving
2.0.3 #
- Fix error when onTabChangeCompleted not defined
2.0.2 #
- Add callback onTabChangeCompleted
2.0.1 #
- Add custom boxfit to foreground image
2.0.0 #
- Add custom your own tabs
1.2.3 #
- Update
1.2.2 #
- Remove MaterialApp and replacing it by a Scaffold since should only be one MaterialApp() per application
- Remove locale since it should handle by primary application (and it is configured by MaterialApp), not by the plugin.
1.2.1 #
- Add optional onSkipPress
1.2.0 #
- Add PREV button and optimize code
1.1.9 #
- Add default go to last page at onSkipPress
1.1.8 #
- Add configuration able to scroll
1.1.7 #
- Fix content scroll overlain bottom view
- Add set width of done, next button
1.1.6 #
- Add option show or hide the status bar
- Adding locale feature, adjust bottom navigation
1.1.5 #
- Fix margin not a type of double
1.1.4 #
- Format code
1.1.3 #
- Add background image
1.1.2 #
- Add custom center widget
1.1.1 #
- Update docs and remove redundant attributes at slide
1.1.0 #
- Add set max number of lines at title
1.0.9 #
- Fix navigate example
1.0.8 #
- Change color options to be instances of
Color
insteadint
1.0.7 #
- Add onCLickImage and maxLines text description
1.0.6 #
- Add gradient background color
1.0.5 #
- Add more attribute
1.0.4 #
- Update info
1.0.3 #
- Update info
1.0.2 #
- Update info
1.0.1 #
- Update
1.0.0 #
- Update
0.0.1 #
- Initial Release


--- layout: post title: Io, Day 3 date: 2011-05-25 21:50:00.000000000 +02:00 categories: [] tags: - Io - Seven Languages in Seven Weeks status: publish type: post published: true meta: _edit_last: '1' _wp_old_slug: io-day-two author: login: admin email<EMAIL_ADDRESS>display_name: Philippe first_name: Philippe last_name: Vlérick excerpt: !ruby/object:Hpricot::Doc options: {} ---
Let’s get down to some coding.
Fibonacci := Object clone
Fibonacci iter := method(n,
l := list(1, 1)
for(i, 2, n, 1,
l append(l at(i - 2) + l at(i - 1))
)
l at(n - 1)
)
Fibonacci rec := method(n,
if(n < 3, 1,
rec(n - 1) + rec(n - 2)
)
)
x := Fibonacci iter(12)
x println
y := Fibonacci rec(12)
y println
For this one, I was a bit stuck with only the book and the language reference, so I had to Google it. And that’s where you have all the beauty and annoyance of the internet: one of the first hit is a solution to that exact question on StackOverflow (it was to be expected.) I was expecting this exercise to take me to the OperatorTable for which there is an example in the book, but actually the operator already exists so it does not have to be added, but instead re-defined for the Number type.
a := list(list(1, 2, 3))
a append(list(4, 5, 6, 7, 8, 9))
a append(list(10, 11, 12))
a append(list(13, 14, 15, 16, 17, 18, 19, 20))
total := 0
for(i, 0, a size - 1,
b := a at(i)
for(j, 0, b size - 1,
n := b at(j)
total = (total + n)
)
)
total println
a := list(1, 2, 3, 4, 5)
b := list(1, "hello")
List myAverage := method(
total := 0
for(i, 0, self size -1,
n := self at(i)
if (n type != "Number",
Exception raise("An item in the list is not a Number"),
total = total + n
)
)
total / self size
)
a myAverage println
b myAverage println
Matrix := Object clone
Matrix list := nil
Matrix dim := method(x, y,
self list := List clone
for(i, 0, x - 1,
l := List clone
for(j, 0, y - 1, l append(nil))
self list append(l)
)
)
Matrix set := method(x, y, value,
self list at(x) atPut(y, value)
)
Matrix get := method(x, y,
self list at(x) at(y)
)
matrix := Matrix clone
matrix dim(4, 2)
matrix set(3, 1, "Hello")
matrix set(1, 1, "World")
matrix get(3, 1) println
matrix get(1, 1) println
Matrix transpose := method(
x := self list at(0) size
y := self list size
m := Matrix clone
m dim(x, y)
for(i, 0, x - 1,
for(j, 0, y - 1,
m set(i, j, self get(j, i))
)
)
m
)
new_matrix := matrix transpose
(matrix get(3, 1) == new_matrix get(1, 3)) println
For this one, decided to aggressively look in the List API to make the code simpler. I discovered quite a lot of useful functions! I also implemented the asString method so that it is easier to debug (the println method on the Object type is implemented to print the result of asString.)
Here is the full code for the whole Matrix object, improved as much as I could:
Matrix := Object clone
Matrix list := nil
Matrix dim := method(x, y,
self list := List clone setSize(x)
for(i, 0, x - 1,
self list atPut(i, List clone setSize(y))
)
)
Matrix set := method(x, y, value,
self list at(x) atPut(y, value)
)
Matrix get := method(x, y,
self list at(x) at(y)
)
Matrix transpose := method(
x := self list at(0) size
y := self list size
m := Matrix clone
m dim(x, y)
for(i, 0, x - 1,
for(j, 0, y - 1,
m set(i, j, self get(j, i))
)
)
return m
)
Matrix asString := method(
s := ""
self list foreach(e,
s := s asMutable appendSeq(e join(",")) asMutable appendSeq("\n")
)
)
Matrix saveTo := method(file,
f := File with(file) remove openForUpdating
self list foreach(i, e,
f write(e join(",")) write("\n")
)
f close
)
Matrix loadFrom := method(file,
l := List clone
f := File with(file) openForReading
f readLines foreach(e,
l append(e splitNoEmpties(","))
)
f close
m := Matrix clone
m dim(l size, l at(0) size)
l foreach(i, e,
e foreach(j, f,
m set(i, j, f)
)
)
m
)
/* Tests */
matrix saveTo("matrix.txt")
new_matrix saveTo("new_matrix.txt")
matrix := Matrix loadFrom("matrix.txt")
new_matrix := Matrix loadFrom("new_matrix.txt")
matrix println
new_matrix println
//Not really random, but will suffice for now
n := Date now second * 1000 % 100
input := File standardInput();
for(i, 1, 10,
guess := input readLine asNumber
if (guess < n, "Hotter" println)
if (guess > n, "Colder" println)
if (guess == n,
"Well done!" println
break
)
)
I really enjoyed myself with these! Looking forward to Day 3...


Document
Open
Prev.
Next
Page
First
Prev.


Days
{d100}
{d10}
{d1}
{hnn}
Hours
:
{mnn}
Minutes
:
{snn}
Seconds
Coming soon
{dnn}
:
{hnn}
:
{mnn}
:
{snn}
See you in The Easy this Friday for the first demo of Concierge. Wake up in style.
This field is required
Please enter a valid email address
This email is already signed
Your email is saved


Expense List
Add Expense
Expense Details Form
Date:
Particulars:
Cost:
Transaction Details:
Save Details


Colarity is a series of experiments & games exploring the interaction of colour, inspired by Josef Albers and his contemporaries.
The purpose of colarity is to recreate the colour workshop environment in a digital space, providing a fun way to explore the interaction of colour.
Return


Monarch Butterfly
Arctic Fox
Shenandoah
Salamander
Whooping
Crane
Emperor
Penguin
Beluga
Whale
Ivory Gull
Koala
Polar Bear
Hawksbill
Sea Turtle
American
Pika
Rusty Patched
Bumble Bee
Common Clownfish
Leatherback
Sea Turtle
Ringed Seal
Ringed Seal
Bicknell's Thrush
Koala
Click an animal to learn more.
Latin name: Phascolarctos Cinereus
Conservsation status: vulnerable (population is decreasing)
The Koala is not a bear, but a marsupial. Like the kangaroo, it carries its young in a pouch. It rarely drinks water—Koala means "no water" in native Australian. Its water and food come from eucalyptus leaves, which are water rich but nutrient poor. To conserve energy, the Koala naps up to 20 hours a day and stays up in its home trees most of the time.
Koalas live in the woodlands of Australia. Thick fur and skin make it difficult for them to adapt to rising temperatures. Increased CO2 in the air produces less protein in the eucalyptus leaves, forcing the Koala to search for other sources of food and, in times of high heat, water. On the ground, the slow moving Koalas are prey to wild dingoes and domestic dogs,
or are hit by cars as
they cross roads. Their habitats are also being destroyed by drought, bush fires and development.


A CRUD webservice - Part 2
In Part 1 of this Show-N-Tell Thursday I showed how to generate a WSDL definition out of a Notes form. While this is nice, it leaves quite a bit of work to actually implement the service. In this installment we take the opposite route. Instead of generating a WSDL definition, LotusScript code will be generated out of a Form definition. Unfortunately DXL doesn't support Web services very well (at least up to R8.0), so I will generate a text file that contains pure LotusScript code. This text file needs to be manually imported into an empty Web service (Copy and paste will do).
I generate a few classes including a custom class which you can overwrite to implement your specific additions to the code. You might want to put that into a different library, so you keep your customization. Nota bene: the generated code is not real production quality. I haven't implemented good logging or error handling ( OpenLog anybody). Once you see the code you get the idea and can complete that easily (feedback would be nice).
A web service requires a LotusScript class with public members, properties and/or functions. Domino Designer will then generate a WSDL file for us. One path to travel would be implementing generic code, that takes fields as name/value pairs. While tempting this has the clear disadvantage, that the web service becomes rather unspecific and we can't take advantage of a strong validation using XML schema. So my approach is to analyze the form and generate 2 XML structures: one for all input fields, used to create and update a document and one for all fields used to read a document. I don't take hide-when formulas into account.
There are a few challenges to overcome. First we need to deal with multi-value fields. In WSDL these are expressed as Arrays. Secondly we need to map the Domino data types to WSDL data types. Luckily half of the work is done since Domino includes "lsxds.lss" It translates WSDL data types into LotusScript. From LotusScript to NotesItems is a path well travelled.
Let's have a look at the XSLT stylesheet (if you don't know how to translate DXL using XSLT use this plug-in -- you are using FireFox are you?)
To instruct the XSLT processor to output plain text rather than XML or HTML we use this statement:
<xsl:output indent= "yes" method= "text" omit-xml-declaration= "yes" media-type= "text/lotuscript" xml:space= "preserve" />
Then inside the root tag the LotusScript Code is written as you would write in Domino Designer.
<xsl:template match= "/" >
<!-- We use the build-in data type mapping for LotusScript agents -->
%INCLUDE "lsxsd.lss"
' Autogenerated code to be embedded into a Domino Web Service
Public Class form <xsl:value-of select= "$formName" />
We have 2 levels of comments here. XSLT Comments looking like this: <!-- ... --> and regular LotusScript comments starting with '.
Whenever we need to get specific we can use <xsl:value-of to pick a value from the DXL form.
The class we will expose into the webservice is, other than its name and the content of the parameters pretty standard and (IMHO) self explaining:
Public Class form <xsl:value-of select= "$formName" />
'/**
'* createData takes in the custom form data and creates a new document.
'* the data given as parameter matches all input fields of the form
'*
'**/
Public Function createData(formData as <xsl:value-of select= "$formName" /> InputData) as ResultCode
Dim curData as new <xsl:value-of select= "$formName" /> CustomData
Set createData = curData.createData(formData)
End Function
Public Function createAndReadData(formData as <xsl:value-of select= "$formName" /> InputData) as ExtendedResult
Set createAndReadData = new ExtendedResult
Set createAndReadData.Data = new <xsl:value-of select= "$formName" /> CustomData
Set createAndReadData.Result = createAndReadData.Data.createData(formData)
End Function
Public Function readData(key as String) as <xsl:value-of select= "$formName" /> CustomData
Dim tmpResult as new <xsl:value-of select= "$formName" /> CustomData
Call tmpResult.readData(key)
Set readData = tmpResult
End Function
Public Function updateData(key as String, formData as <xsl:value-of select= "$formName" /> InputData) as ResultCode
Dim curData as new <xsl:value-of select= "$formName" /> CustomData
Set updateData = curData.updateData(key, formData)
End Function
Public Function updateAndReadData(key as String, formData as <xsl:value-of select= "$formName" /> InputData) as ExtendedResult
Set updateAndReadData = new ExtendedResult
Set updateAndReadData.Data = new <xsl:value-of select= "$formName" /> CustomData
Set updateAndReadData.Result = updateAndReadData.Data.updateData(key,formData)
End Function
Public Function deleteData(key as String) as ResultCode
Dim curData as new <xsl:value-of select= "$formName" /> CustomData
Set deleteData = curData.deleteData(key)
End Function
End Class
Public Class ResultCode
Public Value as Integer 'We use HTTP values
Public DBid as String 'Database and document we try our luck with
Public DocID as String
End Class
Public Class ExtendedResult
Public Result as ResultCode
Public Data as <xsl:value-of select= "$formName" /> CustomData
End Class
The more interesting part is in the generation of code per field. Code needs to be generated for fields in various parts of the code, so we take advantage of XSLT's mode attribute to specify what generation should take place:
<!-- Fields need to be specified per mode/edit/compute and data type -->
<xsl:template match= "d:field" >
<xsl:variable name= "datatype" >
<xsl:call-template name= "getdatatype" >
<xsl:with-param name= "curField" select= "." />
</xsl:call-template>
</xsl:variable>
Public <xsl:value-of select= "@name" /> as <xsl:value-of select= "$datatype" />
</xsl:template>
We actually treat multi-value fields slightly different, so we just add a qualifier to our match condition and we can be more specific what to do. I prefer match clauses to if conditions most of the time.
<!-- We need to treat multivalue fields a little different since they are arrays -->
<xsl:template match= "d:field[@allowmultivalues='true']" >
<xsl:variable name= "datatype" >
<xsl:call-template name= "getdatatype" >
<xsl:with-param name= "curField" select= "." />
</xsl:call-template>
</xsl:variable>
Public <xsl:value-of select= "@name" /> () as <xsl:value-of select= "$datatype" />
</xsl:template>
The variable datatype contains the mapping from a notes datatype into the XSD data type and is implemented as XSLT's version of sub routine. Once you make piece with XSLT's strictly set oriented way of thinking you will appreciate the power of the language. The mapping as of now looks like this:
<!-- Determin the datatype. This maps Notes field types to XML Datatypes. Change as needed -->
<xsl:template name= "getdatatype" >
<xsl:param name= "curField" />
<xsl:choose>
<xsl:when test= "$curField/@type='text'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='keyword'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='password'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='keyword'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='names'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='authors'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='readers'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='formula'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='number'" > XSD_DOUBLE </xsl:when>
<xsl:when test= "$curField/@type='datetime'" > XSD_DATETIME </xsl:when>
<!-- TODO: complete the datatype mapping! -->
<xsl:otherwise> XSD_ANYTYPE </xsl:otherwise>
</xsl:choose>
</xsl:template>
In this case I did choose the <xsl:choose> command since it allows for a compact display and the when conditions are not too complicated. One question to ask: if I only use the type of the field, why would I use the field in the parameter instead of just the type. The answer here is extensibility. You will want to be more specific on datetime and number fields. For a datetime field you could check what parts are visible date and/or time and create XSD_DATE, XSD_TIME instead of XSD_DATETIME. Similar for numbers: based on the display selection you could choose other data types then XSD_DOUBLE.
The sample XSLT stylesheet is available for download.
Next stop: Reverse the game - generate a form from a web service.
I generate a few classes including a custom class which you can overwrite to implement your specific additions to the code. You might want to put that into a different library, so you keep your customization. Nota bene: the generated code is not real production quality. I haven't implemented good logging or error handling ( OpenLog anybody). Once you see the code you get the idea and can complete that easily (feedback would be nice).
A web service requires a LotusScript class with public members, properties and/or functions. Domino Designer will then generate a WSDL file for us. One path to travel would be implementing generic code, that takes fields as name/value pairs. While tempting this has the clear disadvantage, that the web service becomes rather unspecific and we can't take advantage of a strong validation using XML schema. So my approach is to analyze the form and generate 2 XML structures: one for all input fields, used to create and update a document and one for all fields used to read a document. I don't take hide-when formulas into account.
There are a few challenges to overcome. First we need to deal with multi-value fields. In WSDL these are expressed as Arrays. Secondly we need to map the Domino data types to WSDL data types. Luckily half of the work is done since Domino includes "lsxds.lss" It translates WSDL data types into LotusScript. From LotusScript to NotesItems is a path well travelled.
Let's have a look at the XSLT stylesheet (if you don't know how to translate DXL using XSLT use this plug-in -- you are using FireFox are you?)
To instruct the XSLT processor to output plain text rather than XML or HTML we use this statement:
<xsl:output indent= "yes" method= "text" omit-xml-declaration= "yes" media-type= "text/lotuscript" xml:space= "preserve" />
Then inside the root tag the LotusScript Code is written as you would write in Domino Designer.
<xsl:template match= "/" >
<!-- We use the build-in data type mapping for LotusScript agents -->
%INCLUDE "lsxsd.lss"
' Autogenerated code to be embedded into a Domino Web Service
Public Class form <xsl:value-of select= "$formName" />
We have 2 levels of comments here. XSLT Comments looking like this: <!-- ... --> and regular LotusScript comments starting with '.
Whenever we need to get specific we can use <xsl:value-of to pick a value from the DXL form.
The class we will expose into the webservice is, other than its name and the content of the parameters pretty standard and (IMHO) self explaining:
Public Class form <xsl:value-of select= "$formName" />
'/**
'* createData takes in the custom form data and creates a new document.
'* the data given as parameter matches all input fields of the form
'*
'**/
Public Function createData(formData as <xsl:value-of select= "$formName" /> InputData) as ResultCode
Dim curData as new <xsl:value-of select= "$formName" /> CustomData
Set createData = curData.createData(formData)
End Function
Public Function createAndReadData(formData as <xsl:value-of select= "$formName" /> InputData) as ExtendedResult
Set createAndReadData = new ExtendedResult
Set createAndReadData.Data = new <xsl:value-of select= "$formName" /> CustomData
Set createAndReadData.Result = createAndReadData.Data.createData(formData)
End Function
Public Function readData(key as String) as <xsl:value-of select= "$formName" /> CustomData
Dim tmpResult as new <xsl:value-of select= "$formName" /> CustomData
Call tmpResult.readData(key)
Set readData = tmpResult
End Function
Public Function updateData(key as String, formData as <xsl:value-of select= "$formName" /> InputData) as ResultCode
Dim curData as new <xsl:value-of select= "$formName" /> CustomData
Set updateData = curData.updateData(key, formData)
End Function
Public Function updateAndReadData(key as String, formData as <xsl:value-of select= "$formName" /> InputData) as ExtendedResult
Set updateAndReadData = new ExtendedResult
Set updateAndReadData.Data = new <xsl:value-of select= "$formName" /> CustomData
Set updateAndReadData.Result = updateAndReadData.Data.updateData(key,formData)
End Function
Public Function deleteData(key as String) as ResultCode
Dim curData as new <xsl:value-of select= "$formName" /> CustomData
Set deleteData = curData.deleteData(key)
End Function
End Class
Public Class ResultCode
Public Value as Integer 'We use HTTP values
Public DBid as String 'Database and document we try our luck with
Public DocID as String
End Class
Public Class ExtendedResult
Public Result as ResultCode
Public Data as <xsl:value-of select= "$formName" /> CustomData
End Class
The more interesting part is in the generation of code per field. Code needs to be generated for fields in various parts of the code, so we take advantage of XSLT's mode attribute to specify what generation should take place:
<!-- Fields need to be specified per mode/edit/compute and data type -->
<xsl:template match= "d:field" >
<xsl:variable name= "datatype" >
<xsl:call-template name= "getdatatype" >
<xsl:with-param name= "curField" select= "." />
</xsl:call-template>
</xsl:variable>
Public <xsl:value-of select= "@name" /> as <xsl:value-of select= "$datatype" />
</xsl:template>
We actually treat multi-value fields slightly different, so we just add a qualifier to our match condition and we can be more specific what to do. I prefer match clauses to if conditions most of the time.
<!-- We need to treat multivalue fields a little different since they are arrays -->
<xsl:template match= "d:field[@allowmultivalues='true']" >
<xsl:variable name= "datatype" >
<xsl:call-template name= "getdatatype" >
<xsl:with-param name= "curField" select= "." />
</xsl:call-template>
</xsl:variable>
Public <xsl:value-of select= "@name" /> () as <xsl:value-of select= "$datatype" />
</xsl:template>
The variable datatype contains the mapping from a notes datatype into the XSD data type and is implemented as XSLT's version of sub routine. Once you make piece with XSLT's strictly set oriented way of thinking you will appreciate the power of the language. The mapping as of now looks like this:
<!-- Determin the datatype. This maps Notes field types to XML Datatypes. Change as needed -->
<xsl:template name= "getdatatype" >
<xsl:param name= "curField" />
<xsl:choose>
<xsl:when test= "$curField/@type='text'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='keyword'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='password'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='keyword'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='names'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='authors'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='readers'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='formula'" > XSD_STRING </xsl:when>
<xsl:when test= "$curField/@type='number'" > XSD_DOUBLE </xsl:when>
<xsl:when test= "$curField/@type='datetime'" > XSD_DATETIME </xsl:when>
<!-- TODO: complete the datatype mapping! -->
<xsl:otherwise> XSD_ANYTYPE </xsl:otherwise>
</xsl:choose>
</xsl:template>
In this case I did choose the <xsl:choose> command since it allows for a compact display and the when conditions are not too complicated. One question to ask: if I only use the type of the field, why would I use the field in the parameter instead of just the type. The answer here is extensibility. You will want to be more specific on datetime and number fields. For a datetime field you could check what parts are visible date and/or time and create XSD_DATE, XSD_TIME instead of XSD_DATETIME. Similar for numbers: based on the display selection you could choose other data types then XSD_DOUBLE.
The sample XSLT stylesheet is available for download.
Next stop: Reverse the game - generate a form from a web service.
Posted by Stephan H Wissel on 05 September 2007 | Comments (1) | categories: Show-N-Tell Thursday


ChickenRun (2000) 3 1/2 stars out of 4. Featuring the vocal talents of Mel Gibson, Julia Sawalha, Miranda Richardson, Jane Horrocks, Imelda Staunton, Benjamin Whitrow, Lynn Ferguson, Tony Haygarth, Timothy Spall and Phil Daniels. Screenplay by Karey Kirkpatrick and Jack Rosenthal. Directed by Peter Lord and Nick Park. Rated G.
While a student at Ohio University in the late ‘60s (1960s, that is), the university had a program called the MIA, which stood for Movies in Auditorium.
Every Friday and Saturday night, students would troop to Mem Aud, as we called Memorial Auditorium, to see a not-so-old movie.
Two of the most popular - they were screened every quarter - were "The Magnificent Seven" and "The Great Escape." I saw the latter so many times that by my senior year, I'd be whistling along with "The Great Escape's" music track over the opening titles.
What brought this wave of nostalgia to mind was "Chicken Run," a wonderfully daft Claymation comedy from the team behind the popular Oscar-winning `Wallace and Gromit' shorts.
Trapped behind barbed wire, a group of prisoners plot their escape. Time after time, they try and fail to flee their barbaric surroundings.

Led by Ginger (voiced by Julia Sawahla of "Absolutely Fabulous" fame), the hens devise plan after plan, including such classic ruses as tunneling under the compound and cutting through the barbed wire.
"Chicken Run" utilizes all the clichés from the classic p.o.w.-escape genre and, in doing so, brings off one of the most entertaining vehicles of the year.
For the movie takes all the stereotypical elements found in such adventures and endows those characteristics in chickens. There's the Scottish engineer who's always calculating the probability of success or failure and the veteran sergeant-major type who believes in maintaining discipline and tradition even under the most dire circumstances.
Then there''s the solitary Yank, the cocky American who assures the chickens he can lead them in a successful mass exodus.
Rocky (voiced by Mel Gibson) crash lands in the compound, creating the mistaken belief that he can fly. Rocky enjoys all the clucking and fussing. But he neglects to inform the others that the only way he can take to the air is to be shot out of a cannon. Rocky, it is learned, is an escapee from a nearby circus.
Cocky Rocky (he calls himself `the lone free-ranger') bamboozles the hens until the truth is uncovered. But the indomitable Ginger won't give up, leading to a soaring, splendid finale.
"Chicken Run" is witty and charming in that veddy, veddy understated British manner. As directed by Peter Lord and Nick Park, you soon forget the characters are merely clay figures moved frame-by-frame by hand.
There are no computer-generated images here. This movie was done the old-fashioned way, one shot at a time. And the care shows.
"Chicken Run" contains some wonderful moments. Continually thrown into `solitary' (actually a coal bin) for her many escape attempts, Ginger, at one point, begins bouncing a wall off the coal bin wall, a homage to Steve McQueen and "The Great Escape."
A wonderfully scary sequence concerns a Rube Goldberg-like contraption purchased by Mrs. Tweedy who has decided the farm would make more money selling chicken pies than chicken eggs.
Ginger, caught in the deadly machinery, is rescued in the nick of time by Rocky in an exciting sequence.
The movie's vocal talent is first rate.
Sawalha is all determination and grit as the leader of the hens, while Miranda Richardson exudes menace as the evil Mrs. Tweedy, a character who could cause nightmares for the very young viewers.
"Chicken Run," at about 80 minutes, never falters. The uplifting finale will have you cheering. It is an original, entertaining feature the entire family can enjoy.
Bob Bloom is the film critic at the Journal and Courier in Lafayette,IN. He can be reached by e-mail at<EMAIL_ADDRESS>or at<EMAIL_ADDRESS>Reviews by Bloom, an associate member of the Online Film Critics Society, can be found on the Internet Movie Database at: http://www.imdb.com/M/reviews_by?Bob+Bloom
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Toggle navigation
Julia María
Rubio
404 Not Found
The page may have expired, or never existed. Instead, try these:
About
Experience
Education
Contact


Gabriel Serralha Miró
They call me DEVELOPER
I'm a self motivated, quality driven learner...
...and in my spare time I also do some software development - mostly when I'm working or at home.
I've been a software developer (engineer , programmer or any other definition you can come up with ...) since 2006 having worked in major tech companies - like HP and ADP - and also small startup like environments.
Although I'm mostly a Java developer I have never settled for a single technology and have always looked to keep up with the latest tools and frameworks, which made me what you can call an all-around software developer. I have a close interest in Javascript in all its flavors - NodeJS, ES6, Babel, Dart, TypeScript, etc... - and mobile development.
"I'm a self motivated, quality driven learner..."
Besides development I'm always looking into ways to cooperate with business and management by proposing and investigating tools and best practices which enable fast delivery with quality. I've been a Certified Scrum Master and I'm still interested in software development methodologies to optimize the whole development process - Continuous Delivery, Continuous Integration, Test Driven Development and so on...
My current interests range from Neural Networks to peer-to-peer communication protocols to mobile and web development.
"Besides development I'm always looking into ways to cooperate with business and management..."


\begin{figure}[H]
\centering
\maxsizebox{\linewidth}{0.8\paperheight}{\includegraphics[scale=0.8]{{img\string_javascript/ch2-Z-G-13}.svg}}
\caption{The sequence 1, 2, 3, 4 represented as a chain of pairs. }
\label{fig:sequence-of-pairs}
\end{figure}
One of the useful structures we can build with pairs is a
sequence—an ordered collection of data objects. There are, of
course, many ways to represent sequences in terms of pairs. One
particularly straightforward representation is illustrated in
figure \ref{fig:sequence-of-pairs}, where the sequence 1, 2, 3, 4 is
represented as a chain of pairs. The head of each pair is the
corresponding item in the chain, and the tail of the pair is
the next pair in the chain. The tail of the final pair
signals the end of the sequence by pointing to a distinguished
value that is not a pair,
represented in box-and-pointer diagrams as a diagonal line
and in programs as the value of
JavaScript's value null
.
The entire sequence is constructed by nested pair operations:
Such a sequence of pairs is called a
list, and our JavaScript environment provides a
primitive called
list to help in constructing
lists.
The above sequence could be produced by list(1, 2, 3, 4). In
general,
list(a$_{1}$, a$_{2}$, $\ldots$, a$_{n}$)
is equivalent to
pair(a$_{1}$, pair(a$_{2}$, pair($\ldots$, pair(a$_{n}$, null)$\ldots$)))
Our interpreter prints pairs using a textual representation of
box-and-pointer diagrams. The result of
pair(1, 2)
is printed as [1, 2], and
the data object in
figure \ref{fig:sequence-of-pairs}
is printed as
[1, [2, [3, [4, null]]]]:
We can think of
head as selecting the first item in the list, and
of
tail as selecting the sublist consisting of all but the first
item. Nested applications of head and tail can be used to
extract the second, third, and subsequent items in the
list.
The constructor
pair makes a list like the original one,
but with an additional item at the beginning.
The value null,
used to terminate the chain of pairs, can be
thought of as a sequence of no elements, the
empty list.
The use of pairs to represent sequences of elements as lists is
accompanied by conventional programming techniques for manipulating
lists by successively
tailing down
the lists. For example,
the
function
list_ref takes as arguments a list and a number
$n$ and returns the $n$th item of the list. It is customary to
number the elements of the list beginning with 0. The method for
computing list_ref is the following:
- For $n=0$, list_ref should return the head of the list.
n
- Otherwise, list_ref should return the $(n-1)$st item of the
tail of the list.
Often we tail down the whole list. To aid in this, our JavaScript environment includes
a predicate
is_null, which tests whether its argument is
the empty list. The
function
length, which
returns the number of items in a list, illustrates this typical
pattern of use:
The length
function
implements a simple recursive plan. The
reduction step is:
- The length of any list is 1 plus the length of the
tail of the list.
This is applied successively until we reach the base case:
- The length of the empty list is 0.
We could also compute length in an iterative style:
Another conventional programming technique is to
pair up
an
answer list while tailing down a list, as in the
function
append, which takes two lists as arguments and combines their
elements to make a new list:
The function append
is also implemented using a recursive plan.
To append
lists list1 and list2,
do the following:
- If list1 is the empty list, then the result is just list2.
- Otherwise, append the tail of list1 and
list2, and pair the head of list1 onto the result:
\stepcounter{ExerciseDisplayNumber}
\begin{Exercise}
Define a
function
last_pair that returns the list that contains only
the last element of a given (nonempty) list:
\hfill{\hyperref[ex:last-Answer]{Solution}}\\
\end{Exercise}
\begin{Answer}[ref={ex:last}]
\end{Answer}
\stepcounter{ExerciseDisplayNumber}
\begin{Exercise}
Define a
function
reverse that takes a list as argument and
returns a list of the same elements in reverse order:
\hfill{\hyperref[ex:reverse-Answer]{Solution}}\\
\end{Exercise}
\begin{Answer}[ref={ex:reverse}]
\end{Answer}
\stepcounter{ExerciseDisplayNumber}
\begin{Exercise}
\label{ex:unlabeled24}
Consider the
change-counting program of
section \ref{sec:tree-recursion}. It would be nice to be able to
easily change the currency used by the program, so that we could
compute the number of ways to change a British pound, for example. As
the program is written, the knowledge of the currency is distributed
partly into the
function
first_denomination and partly into the
function
count_change (which knows that there are five
kinds of U.S. coins). It would be nicer to be able to
supply a list of coins to be used for making change.
We want to rewrite the
function
cc so that its
second argument is a list of the values of the
coins to use rather than an integer specifying which coins to use. We
could then have lists that defined each kind of currency:
We could then call
cc as follows:
To do this will require changing the program
cc somewhat. It will
still have the same form, but it will access its second argument
differently, as follows:
Define the
functions
first_denomination, except_first_denomination, and no_more in terms of primitive
operations on list structures. Does the order of the list coin_values affect the answer produced by cc? Why or why not?
\hfill{\hyperref[ex:unlabeled24-Answer]{Solution}}\\
\end{Exercise}
\begin{Answer}[ref={ex:unlabeled24}]
The order of the list coin_values
does not affect the answer given by any correct solution of the problem,
because the given list represents an unordered collection of denominations.
\end{Answer}
\stepcounter{ExerciseDisplayNumber}
\begin{Exercise}
\label{ex:unlabeled25}
In the presence of higher-order functions, it is not strictly necessary
for functions to have multiple parameters; one would
suffice.
If we have
a function such as plus that
naturally requires two parameters, we could write a variant of the function
to which we pass the arguments one at
at time. An application of the variant to the first argument could return a
function that we can then apply to the second argument, and so on. This
practice—called
currying and named after the American mathematician and
logician Haskell Brooks Curry—is quite common
in programming languages such as Haskell (the reader might venture a guess
after whom this programming language is named) and Ocaml. In JavaScript, a curried
version of plus looks as follows.
x + y;
}
\end{JavaScriptClickable}
\end{lrbox}
\href{https://sourceacademy.nus.edu.sg/playground#chap=2&prgrm=GYVwdgxgLglg9mABABwDYgM4H0IgE54wCmAJgBQAeAlIgN4CQiTiAUM4nkVPkgJ6IBeAHyIKiANSJeAbhYBfFizSYc+QqTIBmKmQAsVaUA}{\usebox\lstbox}
Write a function brooks, that
takes a curried function as first argument and as second argument a list
of arguments to which the curried function is then applied, one by one,
in the given order. For example, the following application of
brooks should have the
same effect as the call plus_curried(3)(4) above.
While we are at it, we might as well curry the function
brooks! Write
a function
brooks_curried that
can be applied as follows, to yield the same result 7:
With this function
brooks_curried
what are the results of evaluating the following two statements?
\hfill{\hyperref[ex:unlabeled25-Answer]{Solution}}\\
\end{Exercise}
\begin{Answer}[ref={ex:unlabeled25}]
\begin{enumerate}[a.]
\item{
}
\item{
}
\item{
The statement
of course evaluates to 7, as does
}
\item{
}
\end{enumerate}
\end{Answer}
One extremely useful operation is to apply some transformation
to each element in a list and generate the list of results.
For instance, the following
function
scales each number in a list by
a given factor:
We can abstract this general idea and capture it as a common pattern
expressed as a higher-order
function, just as in
section \ref{sec:higher-order-procedures}. The higher-order
function
here is called map. The function map takes as arguments a
function
of one argument
and a list, and returns a list of the results produced by
applying the
function
to each element in the list:
x * x, list(1, 2, 3, 4));
\end{JavaScriptClickable}
\end{lrbox}
\href{https://sourceacademy.nus.edu.sg/playground#chap=2&prgrm=GYVwdgxgLglg9mABAWwIYAcAUowBpExQCmyAzgJSIDeAUIvYgE5FQiNIykD6YIANn0yESFOg3EMA-Il4CxE8QC5E6VDEbZwmABZFUAEyHEy5cvnkLL9NFhz4oawcJOmA3DQC+NG5gAeiAF4APkR-ACpQ-D5OKEwARnwAJnwAZnwAFjcgA}{\usebox\lstbox}
Now we can give a new definition of scale_list in terms of map:
x * factor, items);
}
\end{JavaScriptClickable}
\end{lrbox}
\href{https://sourceacademy.nus.edu.sg/playground#chap=2&prgrm=GYVwdgxgLglg9mABAZwgQwDYFMD6GbJQAUMUWAtsgDSLBrRwBOAlIgN4BQi3ijWUIRknJoADkQAeiALwA+RFIBUtelCY1SFZMwDcHAL4cOqTLnyEi54gEYaAJhoBmGgBYaAVmY1rABl1A}{\usebox\lstbox}
The function map
is an important construct, not only because it captures a
common pattern, but because it establishes a higher level of
abstraction in dealing with lists. In the original definition of scale_list, the recursive structure of the program draws attention to
the element-by-element processing of the list. Defining scale_list in terms of map suppresses that level of detail and
emphasizes that scaling transforms a list of elements to a list of
results. The difference between the two definitions is not that the
computer is performing a different process (it isn't) but that we
think about the process differently. In effect, map helps
establish an abstraction barrier that isolates the implementation of
functions
that transform lists from the details of how the
elements of the list are extracted and combined. Like the barriers
shown in figure \ref{fig:abstraction-barriers}, this abstraction gives
us the flexibility to change the low-level details of how sequences
are implemented, while preserving the conceptual framework of
operations that transform sequences to sequences.
section \ref{sec:sequences-conventional-interfaces} expands on this use
of sequences as a framework for organizing programs.
\stepcounter{ExerciseDisplayNumber}
\begin{Exercise}
The
function
square_list takes a list of
numbers as argument and returns a list of the squares of those
numbers.
Here are two different definitions of square_list. Complete
both of them by filling in the missing expressions:
\hfill{\hyperref[ex:square-list-Answer]{Solution}}\\
\end{Exercise}
\begin{Answer}[ref={ex:square-list}]
\end{Answer}
\stepcounter{ExerciseDisplayNumber}
\begin{Exercise}
Louis Reasoner tries to rewrite the first square_list
function
of
exercise \ref{ex:square-list} so that it evolves an iterative
process:
Unfortunately, defining square_list this way produces the answer
list in the reverse order of the one desired. Why?
Louis then tries to fix his bug by interchanging the arguments to
pair:
This doesn't work either. Explain.
\hfill{\hyperref[ex:iter-square-list-Answer]{Solution}}\\
\end{Exercise}
\begin{Answer}[ref={ex:iter-square-list}]
\begin{enumerate}[a.]
\item{
The result list is reversed in the first program
because the argument list is traversed in the
given order, from first to last, but squares are added successively to the
front of the answer list via
pair.
The last element of the list is the last one to be added to the answer
and thus ends up as the first element of the result list.
}
\item{
The second program makes things worse! The result is not even a list any longer,
because the elements occupy the tail position of the result list and not the
head position.
}
\end{enumerate}
\end{Answer}
\stepcounter{ExerciseDisplayNumber}
\begin{Exercise}
The
function
for_each
is similar to map. It takes as arguments a
function
and a list of elements. However, rather than forming a list of the results,
for_each
just applies the
function
to each of the elements in turn, from left to right.
The values returned by applying the
function
to the elements are not used at
all—for_each is used with
functions
that perform an action, such as printing. For example,
display(x),
list(57, 321, 88));
\end{JavaScriptClickable}
\end{lrbox}
\href{https://sourceacademy.nus.edu.sg/playground#chap=2&prgrm=PTAEDMHsCcH0FMCGBjAFqALpUAjeoBzASwDd4A7XAT1AGcMBXAEwowCgo4k0AKAD1ABeAHygmRWgAcANoir8AlABpQbUOo0bpEjDwCsAdhUBmAEwBGFQA4rChQG4gA}{\usebox\lstbox}
The value returned by the call to
for_each
(not illustrated above)
can be something arbitrary, such as true. Give an
implementation of
for_each.
\hfill{\hyperref[ex:for-each-Answer]{Solution}}\\
\end{Exercise}
\begin{Answer}[ref={ex:for-each}]
\end{Answer}


Workshop
Building a JBoss BPM Travel Agency
Now we have created the last rules we needed, time to complete the Travel Agency
BPM process which will leverage the rules and services. The process we will be completing
in this lab is a sub-process called 'calculatepriceprocess' and is used
by the main Travel Agency process to validate data, calculate discount pricing and to calculate
the final pricing.
Lab 03 - Complete the Travel Agency BPM Process
Lab Goal
To complete the JBoss BPM Travel Agency pricing process using the process modeler and previously completed rules.
Complete the BPM process
- In project authoring open the Calculate Price Process:
AUTHORING -> PROJECT AUTHORING -> BUSINESS PROCESSES -> calculatepriceprocess
- Note errors due to being incomplete, so let's fix that!
Complete the BPM process
- The process is a sub-process called by the main process
- Let's look at the data being passed into this process:
- click on the main process pallet (white background)
- slide out the
Properties
pane on the right
- we see that the
Variable Definitions
are empty, so no data has been
passed into this sub-process, why?
Complete the BPM process
- So where does our data for the rules (our facts) come from? How can we call rules without any facts?
- In the main process we find the answer:
- the facts were put into memory (into a session) for us, in 'Prepare Data', before calling
the sub-process
Complete the BPM process
- We can now work directly with our rules, starting with deciding if the data submitted is valid
- To do this we need to setup the
'Rejection'
node:
- click on
Rejection
to select
- slide open
Properties
panel on the right
Complete the BPM process
- We need to set the following field:
Task Type: Business Rule
- note the change to the node, a rule icon now identifies it
Complete the BPM process
- We need to set the following field:
Ruleflow Group: rejection
- open the pop-up editor, view the rules in
'rejection'
, select rejection
, click on Save
Complete the BPM process
- The validation rules are now used in
Rejection
Complete the BPM process
- In the following gateway node, the path
Rejection
checks for a Rejection object in memory
- This will be there if the validation rules detect data that fails our rules
- It's done for you in
Properies -> Expression
:
org.specialtripsagency.Rejection()
Complete the BPM process
- In the following gateway node, the
Not Rejected
path verifies that there
is not a Rejection object in our session
- It's done for you in
Properies -> Expression
:
not org.specialtripsagency.Rejection()
Complete the BPM process
- Next is discount rule, provided as a decision table
- Let's look at this before we setup our rule task:
Guided Decision Tables -> AdditionalTravelersDiscount
and expand
- note options list
ruleflow-group: 'discount'
Complete the BPM process
- Back to the process, setup discount rule task:
- click on
'Apply Additional Travelers Discount'
to select
- slide open
Properties
panel on the right
Complete the BPM process
- We need to set the following field:
Task Type: Business Rule
- note the change to the node, a rule icon now identifies it
Complete the BPM process
- We need to set the following field:
Ruleflow Group: discount
- open the pop-up editor, view the rules in
'discount'
, select discount
, click on Save
Complete the BPM process
- The discount rules are now used in
Apply Additional Travelers Discount
Complete the BPM process
- Next up is the total price calculations as a technical rule
- Let's look at this before we setup our rule task:
- to view click on
DRL -> CalculateTotalPriceOnDiscountProvided
Complete the BPM process
- Back to the process, setup total calculation with a rule task:
- click on
'Calculate Total'
to select
- slide open
Properties
panel on the right
Complete the BPM process
- We need to set the following field:
Task Type: Business Rule
- note the change to the node, a rule icon now identifies it
Complete the BPM process
- We need to set the following field:
Ruleflow Group: total
- open the pop-up editor, view the rules in
'total'
, select total
, click on Save
Complete the BPM process
- The total rules are now used in
Calculate Total
Complete the BPM process
- Next up are the retract rules, a set of guided rules to clean up all facts from the
current session before we exit our sub-process.
- the rules are under
GUIDED RULES -> Retract*
(rules pre-fixed with Retract)
Complete the BPM process
- Back to the process, setup retract with a rule task:
- click on
'Retract Facts'
to select
- slide open
Properties
panel on the right
Complete the BPM process
- We need to set the following field:
Task Type: Business Rule
- note the change to the node, a rule icon now identifies it
Complete the BPM process
- We need to set the following field:
Ruleflow Group: retract
- open the pop-up editor, view the rules in
'retract'
, select retract
, click on Save
Complete the BPM process
- The retraction rules are now used in
Retract Facts
Complete the BPM process
- The Calculate Price sub-process is now finished
- click on mini disk icon top right in designer, save, add commit message
Complete the BPM process
- Also note all
Message
errors at the bottom are gone
- click on refresh in the bottom pane, if still errors, correct them!
Ensure project builds
- Before you build project, ensure there are no active deployments
Deploy -> Process Deployments
- if exists an entry for
Special Trips Agency 2.0.0
then remove by clicking on mini icon
Ensure project builds
- right pane ->
OPEN PROJECT EDITOR -> BUILD (top right) -> BUILD & DEPLOY
(should see green pop-up 'Build Successful')
Building the Travel Agency
(next up, building JBoss Fuse microservices...)
- Racing Camel with BPM and Red Hat JBoss Fuse


Slippages
The project
The Science
The Creative Process
From Sight to Sound
The Premiere
Artist's Documents
The Outcomes
About
Affiliations
Acknowledgements
Explore Slippages in
the UBC Open Collections
IIIF Manifest
http://localhost:4000/slippages


Sign Up
Login
Guest
About
Meet Our Team
TeamLeader Dustin Snoap
Front End React Engineer Michael Levick, Jr.
Front End React Engineer Robert Elias
Back End Engineer Louis Gelinas
IOS Engineer Brian Vilchez
IOS Engineer Jerry Haasar
User Interface Patrick Roach


Steve Klabnik
Rust is a programming language.
It's been in development a long time.
It's been one year since 1.0.
I'm here to tell you about that.
I'm not going to say more about Rust itself yet. We'll get there!
First, let's talk about why you should care about this story.
This is a story about history
History can be divided up into 'epochs'
Epochs are determined by the predominant paradigm of the time
As things change, the paradigm (and hence the epoch) changes
Rust has undergone four epochs so far:
The Personal Years (2006-2010)
The Graydon Years (2010-2012)
The Typesystem Years (2012-2014)
The Release Year (2015 -> May 2016)
We are now entering a new epoch: The Production Year (May 2016 -> ?)
It took a long time to figure out how Rust ought to work. - Niko
It's basically a completely different language if you compare by features.
It's basically the exact same language if you compare by goals.
Eight years is a long time.
Rust and Servo are both written in Rust.
"This feature seems cool" -> implement -> try it out
Cool? Keep it.
Not cool? Throw it out!
Rust has lost more features than many languages have in the first place.
Iteration does not mean identity crisis. The 'how' may not be clear, but the goal can be.
Rust has undergone four epochs so far:
The Personal Years (2006-2010)
The Graydon Years (2010-2012)
The Typesystem Years (2012-2014)
The Release Year (2015)
We are now entering a new epoch: The Production Year (May 2016 -> ?)
I have been writing a compiled, concurrent, safe, systems programming language for the past four and a half years.
We do not know what exactly will come of it.
Many older languages better than new ones. We keep forgetting already-learned lessons.
Technology from the past come to save the future from itself
fn main() { log "hello, world"; }
fn max(int x, int y) -> int { if (x > y) { ret x; } else { ret y; } }
obj counter(int i) { fn incr() { i += 1; } fn get() -> int { ret i; } } fn main() { auto c = counter(10); c.incr(); log c.get(); }
obj swap[T](tup(T,T) pair) -> tup(T,T) { ret tup(pair._1, pair._0); } fn main() { auto str_pair = tup("hi", "there"); auto int_pair = tup(10, 12); str_pair = swap[str](str_pair); int_pair = swap[int](int_pair); }
The semantics is the interesting part. The syntax is, really, about the last concern.
Rust now a Mozilla project, with Graydon as a BDFL-style figure.
Steady rate of improvement and change.
The team slowly grows.
As the team grows, the typesystem grows as well.
As the typesystem grows, more and more moves from the language to the libraries.
Graydon steps down from the project.
Case study: Channels
rec(task task, chan[T] chan)
task
and chan
are keywords that the language knows about.
Case study: Channels
use std::thread::Thread; use std::sync::mpsc::{Sender,Receiver}; struct Foo<T> { thread: Thread, chan: (Sender<T>, Receiver<T>), }
Case study: Pointers
let x = @5; // GC'd pointer let y = ~5; // unique pointer let z = &5; // borrowed pointer
Case study: Pointers
let y = Box::new(5); // box let z = &5; // reference
Not typesystem related: Cargo and Crates.io
$ cargo new foo --bin
$ cd foo
$ cargo run
Compiling foo v0.0.1 (file:///home/steve/tmp/foo)
Running `target/foo`
Hello, world!
Not typesystem related: Cargo and Crates.io
$ cargo build -v
Compiling foo v0.0.1 (file:///home/steve/tmp/foo)
Running `rustc src/main.rs --crate-name foo --crate-type bin -g --out-dir /home/steve/tmp/foo/target --emit=dep-info,link -L dependency=/home/steve/tmp/foo/target -L dependency=/home/steve/tmp/foo/target/deps`
Enable common patterns:
$ cargo build --release -v
Compiling foo v0.0.1 (file:///home/steve/tmp/foo)
Running `rustc src/main.rs --crate-name foo --crate-type bin -C opt-level=3 --cfg ndebug --out-dir /home/steve/tmp/foo/target/release --emit=dep-info,link -L dependency=/home/steve/tmp/foo/target/release -L dependency=/home/steve/tmp/foo/target/release/deps`
Not typesystem related: Cargo and Crates.io
$ cat Cargo.toml
[package]
name = "foo"
version = "0.0.1"
authors = ["Steve Klabnik<EMAIL_ADDRESS>Not typesystem related: Cargo and Crates.io
$ cat Cargo.toml
[package]
name = "foo"
version = "0.0.1"
authors = ["Steve Klabnik<EMAIL_ADDRESS>[dependencies]
time = "*"
log = "0.2.1"
$ cargo build
Updating registry `https://github.com/rust-lang/crates.io-index`
Compiling log v0.2.1
Compiling libc v0.1.1
Compiling gcc v0.1.7
Compiling time v0.1.15
Compiling foo v0.0.1 (file:///home/steve/tmp/foo)
As Rust's community grows, three large camps form:
In some ways, Rust is a combination of all three of these things.
March 2014: RFC process begins
v = []
v.push("Hello")
x = v[0]
v.push("world")
puts x
#include<iostream>
#include<vector>
#include<string>
int main() {
std::vector<std::string> v;
v.push_back("Hello");
std::string& x = v[0];
v.push_back("world");
std::cout << x;
}
$ g++ hello.cpp -Wall -Werror
$ ./a.out
Segmentation fault (core dumped)
If the new size() is greater than capacity() then all iterators and references (including the past-the-end iterator) are invalidated.
fn main() { let mut v = vec![]; v.push("Hello"); let x = &v[0]; v.push("world"); println!("{}", x); }
$ cargo run
Compiling hello_world v0.0.1 (file:///Users/you/src/hello_world)
error: cannot borrow `v` as mutable because it is also borrowed as immutable
v.push("world");
^
note: previous borrow of `v` occurs here; the immutable borrow prevents
subsequent moves or mutable borrows of `v` until the borrow ends
let x = &v[0];
^
note: previous borrow ends here
fn main() {
...
}
^
error: aborting due to previous error
use std::thread; fn main() { let guards: Vec<_> = (0..10).map(|_| { thread::spawn(|| { println!("Hello, world!"); }) }).collect(); }
use std::thread; fn main() { let guards: Vec<_> = (0..10).map(|_| { thread::spawn(|| { println!("Hello, world!"); }) }).collect(); }
error: capture of moved value: `numbers`
use std::thread::Thread; use std::sync::{Arc, Mutex}; fn main() { let numbers = Arc::new(Mutex::new(vec![1, 2, 3])); let mut handles = Vec::new(); for i in 0..3 { let number = numbers.clone(); let handle = thread::spawn(move || { let mut array = number.lock().unwrap(); array[i] += 1; println!("numbers[{}] is {}", i, array[i]); }); handles.push(handle); } for handle in handles { handle.join().unwrap(); } }
extern crate crossbeam; fn main() { let numbers = [1, 2, 3]; crossbeam::scope(|scope| { for i in &mut numbers { scope.spawn(move || { numbers[i] += 1; println!("numbers[{}] is {}", i, numbers[i]); }); } }); }
Continual pushing the boundaries of what's possible.
It's not just about the language, it's about the ecosystem.
It's not just about the language, it's about the tooling.
It's not just about the language, it's about stability.
It's not just about the language, it's about the community.
Ecosystem:
rustc
Tooling:
Makefile
again.rustfmt
: coming soonrustfix
: not as strongly needed because...Stability:
Community:
Now that we've built a thing... time for people to use it!
I love Rust, and I hope you do too. If you don't, that's totally cool.
What will the future of this story be? We hope you'll join us in writing the next epoch.
Thank you! <3


"Getting blocked on a simple problem"
For me the biggest road block I hit was during one of the Katas, "Manipulating JS Objects" where one of the tests stated,
"The value of the terah children property should be defined as an Object"
now for some this may have seemed extremely easy and I knew it must be something super simple but I just couldn't get my head around it, I tried Googling for how to declare a property as an Object and funnily enough I was getting all these complicated answers that I thought seemed way to overcomplicated and what seemed like the simplest answer I could find was to use the "defineProperty()" method though no matter what I tried I just couldn't get it to work.
Eventually I asked one of my cohorts about that particular test and sure enough, the answer was indeed very simple, rather than trying to use a method to assign a property to an Object and trying to declare that it was another Object, I just had to declare an Object like you would any other, but use the accessor using dot notation as a name for said Object "terah.children" and just like that it passed.
My two take away lessons from that experience is sometimes the simpliest and most fundamental answers can be the hardest to find, and sometimes all you need is a second pair of eyes and a different perspective to get things working.
"Solving a problem in an elegant way"
In all honesty, I don't think I'm anywhere near the level yet where I can fairly determine whether any of my solutions are "elegant" as of yet, since I'm still quite inexperienced in terms of my coding ability, I can at least say that I solved them, which is the most important thing in my book.
"Psuedocode"
Pseudocode is not my strongest skill and definitely needs a lot more practice for me to get better at it, but it is certainly a good idea that helps quite a bit just like talking a problem through to someone else is very useful and I will keep trying to implement it as I progress for sure.
"Trying something"
Most of the time this rarely works for me honestly, but I give it a shot all the same now and again, no doubt as my skills improve the success rate with this will improve as time goes on.
"Rubber ducky method"
The rubber ducky method is certainly something I try and do all the time when I'm working at home either with my cat or with a miniature owl (instead of a duck) I keep at my desk at home, it makes a big difference saying things out loud even if you may not think so, it certainly made a few things a lot more straight forward once I did it.
"Reading error messages"
I find reading the error message can sometimes be a little obscure and confusing in some cases but slowing down, reading and giving it some thought can make a big differnence and if it's too obscure and confusing using Google to learn more about it is always helpful in my experience limited as it might be.
"Console.logging"
Console.log is really useful and is often helpful at getting my bearings on how I've applied my code. I'd say I'm quite confident with console.log.
"Googling"
Google is my best friend and has already saved me a lot of trouble on various problems, I find the key to using Google successfully is if you're not finding anything useful is to try and rephrase the question in a different way, finding the right answers on Google is a skill in it's own right
"Asking your peers for help"
Out of everything listed here this is one of the most useful things to do simply getting a second pair of eyes and a different perspective on a problem helps immensely for me. Even if I can be a bit stubborn at trying to figure it out by myself.
"Asking your coaches for help"
So far I've not gotten stuck to the point where I've needed to ask any of the coaches for help not yet that is.
"Improving my process with reflection"
I find having to break down and explain a concept wether it be in person or in writing is the best way to keep tabs on yourself and make sure you really understand what you've learned, I've personally always found that there is a big differnce between "knowing" something and "understanding" something and reflections certainly serve me well in that regard.


Follow these steps after selecting Zerodha as your brokerage in the tutorial in the introduction:
$ lean live "My Project" API key: hp9erb9ct0lqaxpm Access token: ********************
MIS
if you are targeting intraday products, CNC
if you are targeting delivery products, or NRML
if you are targeting carry forward products.
$ lean live "My Project" Product type (MIS, CNC, NRML): MIS
EQUITY
if you are trading equities on NSE or BSE, or COMMODITY
if you are trading commodities on MCX.
$ lean live "My Project" Trading segment (EQUITY, COMMODITY): EQUITY
Follow these steps after selecting Zerodha as your data feed in the tutorial in the introduction:
$ lean live "My Project" Do you have a history API subscription? [y/N]: y


{{extend 'layout.html'}}
{{=T("You tried to do an irregular operation. An e-mail was sent to the website administrator.")}}


Note onset detection
Prong contains a note onset detection algorith, which looks for jumps in the amplitude of the waveform.


Field must start with an alphabet (character limit :
2-40) and special Characters are not allowed.!
Required field* (Limit : 1-40)
Field must start with an alphabet (character limit :
2-40) and special Characters are not allowed.!
Required field*
Field must start with an alphabet (character limit :
2-40) and special Characters are not allowed.!
Required field*
Required field*
Required field*
Field must start with an alphabet (character limit :
2-40) and special Characters are not allowed.!
Required field* (Limit : 1-40)
Required field*
Required field* (Limit : 1-40)
Field must start with an alphabet (character limit
: 2-40) and special Characters are not allowed.!
Required field* (Limit : 1-20)
Field must start with an alphabet (character limit
: 2-40) and special Characters are not allowed.!
Required field* (Limit : 1-40)
Field must start with an alphabet (character limit
: 2-40) and special Characters are not allowed.!


{% extends "blog/base.html" %} {% block content %}
Features: Authentication System | CRUD based Blog | Django Debug Toolbar
Superuser: Register | Login/Logout | Post Blog | Control Comment | Edit Site
Visitors: Make Comment | Review Author/Resume | Link to author's other websites
I'm Yutong Liu, a Full Stack Software Engineer in Huawei Technologies currently. My daily work is to utilize my Full Stack skills to refactor, optimize and maintain our website for a higher user number.
I also significantly reduced company's data process procedure via template scripts development and database setup when I was in E-Joule.
If I may summarize myself in three tags, I'd like to tag me as a team player, a creative executor, and a fast learner.


Bayesian analysis. Application to image reconstruction
The course will not be taught during 2020-2021.
This course is taught to MAUCA students.
Abstract
The course aims to familiarize the students with the Bayesian analysis. The Bayesian paradigm, coupled with efficient simulation algorithms, has been proved to be a computationally efficient alternative to classical frequentist approaches.
The Bayesian formalism is also recognized as a natural framework to address inverse problems which arise in many observational systems. A large part of the course is devoted to the application of Bayesian models to image reconstruction in astrophysics. It will particularly focus on choice of the priors and the implementation.
Theory
A common problem in experimental and observational sciences is to extract information from noisy measurements. Bayesian analysis is the formalism which allows to merge in the inference: 1. the information brought by the measurements, 2. a prior on the solution.
This approach is experiencing an increasing interest since the early 1990’s after new simulations methods appeared. Since a decade, the Bayesian paradigm coupled with hierarchical models is used to solve computationally involving problems where mathematical optimization algorithms are replaced by increasingly effective simulations methods.
Besides the power of recent computational Bayesian approaches, the Bayesian formalism plays also a central role in the resolution of inverse problems.
Many data processing problems in physics, and in particular in astrophysics, can be formalized as an inverse problem where the measured data is related in a complex way to the properties of the target. This includes image deconvolution (e.g. deblurring and denoising), image reconstruction (e.g. in radioastronomy or optical interferometry), image segmentation… The resolution of these ill-posed problems require a regularization (or prior) and the Bayesian formalism is proved to be the natural framework to address these problems.
Applications
A large part of the course is devoted to practical projects, where the students will code various algorithms and compare theoretical results with simulation results. Students will have to complete three projects during the course and are welcomed to work in pairs and to submit a single document. The computations will be preferentially carried out in julia, python or matlab.


WQMY
Lynchburg Mazda Nissan: Forest, VA, 24551-4051 Car Dealership ...
Lynchburg Mazda Nissan dealership in Forest, VA at AutoTrader.com. View new, used and certified car specials and get financing from a Forest car dealer.
http://www.autotrader.com/dealer/info/VA/Forest/24551-4051/80903/Lynchburg_Mazda_Nissan.jsp
| three monitor video cards/tutankhamen's strengths and weaknesses/ chemical structure of germanium |
|
|---|---|
| fort mason festival pavilion | Williamsport |
| Branding | MyNetworkTV mazda car dealer in lynchburg virginia |
| marty in mario cart 64 | traditinal swedish christmas dinner: 29 (director and zombie movie) & making chicken cordon bleu-DT 45.3 (UHF) |
| nema electrical safety rating | see article |
| Owner | New Age Media, LLC Lynchburg Car Dealers - Find New Car Dealerships in ... - Motor Trend |
| First air date | December 30, 1988 |
| principios de derecho constitucional | MYNetworkTV |
| cell phone deal of the day | WOLF-TV, cheques de pago de n mina |
| to to increase wireless headphone range | WILF (1988-2006) |
| Former channel number(s) | LYNCHBURG MAZDA Dealer, FOREST - VIRGINIA Mazda ... |
| swimming costume size 20 | apartment guide toledo ohio (1988-1998) spongebob squarepants the movie 3d game / mountain view laser eye surgery (1998-2006) |
| new computer viruses or hoaxes | 50 307 level 23 franklin legal brisbane 420 kW (WOLF-DT3) |
| marc's cafe coffee mill | 243 m 488 m (WOLF-DT3) |
| tell me you love me series | 52075 73375 (WOLF-DT3) |
| Transmitter coordinates | sky tv broadband phone auto insurance quote conroe (WOLF-DT3) |
Lynchburg Mazda Nissan - Forest, VA - Dealership Research
Learn about Lynchburg Mazda Nissan on Cars.com. Read reviews by dealership customers, get directions, contact the dealer.
http://www.cars.com/dealers/151424/lynchburg-mazda-nissan
Lynchburg Nissan
18588 Forest Rd, Forest VA 24551. Sales:<PHONE_NUMBER>. Lynchburg Nissan on facebook facebook; Lynchburg Nissan on twitter twitter; Lynchburg Nissan on .
http://lynchburgnissan.com/
Contents |
[marty in mario cart 64] History
lynchburg cars & trucks - all classifieds - craigslist
////Great car/Accord 'o3** $1973 ( lynchburg ) pic dealer . Only 61 Miles Mazda Sedan MAZDA6 2004 ID#<PHONE_NUMBER>297 $1996 (virginia) img dealer .
http://lynchburg.craigslist.org/cta/
Lynchburg Mazda
Lynchburg Mazda. 18576 Forest Rd, Forest VA 24551. Sales:<PHONE_NUMBER>; Service:<PHONE_NUMBER>; Parts:<PHONE_NUMBER> .
http://lynchburgmazda.com/
New & Used Car Dealers | Roanoke Lynchburg VA | Berglund Auto ...
Plus, we have a Kawasaki Motorcycle dealership and an Outdoors store. In addition to a wide selection of new and used vehicles in the Lynchburg, VA, area, .
http://www.berglundcars.com/
Lynchburg Dealerships - Locate New and Used Lynchburg, VA Car ...
. new and used cars. Read user reviews, map Lynchburg Car Dealerships and view dealer incentives. . Locate and Review Lynchburg, VA Car Dealers. Share .
http://autos.aol.com/car-dealers/lynchburg-va/
Lynchburg Mazda - Mazda - Dealership Ratings
Lynchburg, Virginia 24551 . Write a review of Lynchburg Mazda . Getting a car from the mazda dealership was such a wonderful experience and I can .
http://www.dealerrater.com/dealer/Lynchburg-Mazda-review-35913/
Salem VA Mazda Dealer | New Mazda & Used Cars Roanoke ...
Used car dealer and New Mazda in Salem, VA offers Roanoke area used cars and new Mazda vehicles to Christiansburg, Martinsville, and Lynchburg, VA .
http://www.berglundmazdasalem.com/
Find Mazda Dealers in Lynchburg, Virginia
Edmunds.com can get you started on the right track with a convenient directory of Mazda car dealerships in and around Lynchburg, Virginia. Compare online .
http://www.edmunds.com/dealerships/Mazda/Virginia/Lynchburg.html
Lynchburg Mazda Nissan - Forest, Virginia: Used Cars for Sale ...
See Lynchburg Mazda Nissan Used Cars on Cars.com. Visit Lynchburg Mazda Nissan in Forest, Virginia to see a variety of new and used Cars waiting for you. . Dealer: Lynchburg Mazda Nissan (Forest, VA ).<PHONE_NUMBER>. Email Dealer .
http://www.cars.com/for-sale/searchresults.action?stkTyp=U&dlId=447727
Lynchburg Mazda Nissan Reviews - Forest, VA - Dealership ...
See how customers rate Lynchburg Mazda Nissan in Forest, VA. Read reviews of this dealership and write your own review.
http://www.cars.com/dealers/151424/lynchburg-mazda-nissan/reviews
Lynchburg Used car dealers | Used car dealers in Lynchburg, VA ...
Results 1 - 30 of 76 . 76 listings of Used Car Dealers in Lynchburg on YP.com. Find reviews . 18557 Forest Rd, Lynchburg, VA 24502 » Map<PHONE_NUMBER> .
http://www.yellowpages.com/lynchburg-va/used-car-dealers
Virginia Mazda Dealers - Dealer Directory - AutoSpies
Review Virginia Mazda Dealers Reviews. . Dealer Directory >> Virginia Car Dealers >> Mazda Dealers >> Select a Virginia . Lynchburg Mazda Reviews .
http://www.autospies.com/dealers/Mazda/Virginia/
[cell phone deal of the day] Digital channels
| Channel | Name | bsa and video games | brewpubs in staten island ny | Programming |
|---|---|---|---|---|
| 53.1 | mazda car dealer in lynchburg virginia DT | prestige motors long island city | clanton malphus hodges vet | Main mazda car dealer in lynchburg virginia programming / MyNetworkTV |
| 53.2 | WOLF DT | home everything appliance store | pass your driving test uk | Simulcast of practice final for 6th grade science |
| 53.3 | WSWB DT | 480i | 4:3 | Simulcast of 500ms time delay circuit |
Virginia Mazda Dealers - Dealer Directory - DealerRater
Review Virginia Mazda Dealers Reviews & Read Helpful Consumer Information about . Read Reviews; Write A Review; Cars for Sale; My Tools; About Us .
http://www.dealerrater.com/directory/Virginia/Mazda/
[sewer outlet from basement] References
[la graciosa lanzarote photos] External links
- peter tilton nj bayville
- electric specialty vehicles for disablities
- coturnix quail day old chicks
- good eats power bars
- home
- make vista look like mac
|
|