Following pictures are explaining how to install Fuzuli on Ubuntu 12.04 LTS using the DEB package given in http://code.google.com/p/fuzuli/downloads/list
Friday, June 1, 2012
Thursday, May 31, 2012
Mathematics with Fuzuli
Fuzuli has several packages which are mostly wrappers of C++ libraries. One of them is the math package. It is math.nfl and stated in /usr/lib/fuzuli/nfl in Linux installations by default.
The math.nfl package simple wraps some basic mathematical functions such as square root, exponential, logarithms, floor, ceil and round as well as trigonometric functions such as sin, cos, tan, atan, acos, etc. These functions are directly inherited from the standard C++ library. A list of functions in the math.nfl package is shown below:
| Function | Description | Example | Result |
| PI | Returns a short presentation of PI | (let a (sin (/ PI 2))) | 1.0 |
| sin | Returns sin of a given reference | (let a (sin 0)) | 0.0 |
| cos | Returns cos of a given reference | (let a (cos 0)) | 1.0 |
| tan | Returns tan of a given reference | (print (tan 1)) | 1.55741 |
| abs | Returns absolute value | (print (abs -5)) | 5 |
| sqrt | Returns square root | (print (sqrt 25)) | 5 |
| exp | Returns E^x | (print (exp 1)) | 2.71828 |
| log | Returns natural logarithm | (print (log (exp 1))) | 1.0 |
| log10 | Returns logarithm in base 10 | (print (log10 10)) | 1.0 |
| log2 | Returns logarithm in base 2 | (print (log2 2)) | 1.0 |
| cosh | Returns hyperbolic cos | (cosh x) | |
| sinh | Returns hyperbolic sin | (sinh x) | |
| tanh | Returns hyperbolic tan | (tanh x) | |
| asin | Returns inverse sine | (asin 1) | |
| acos | Returns inverse cosine | (acos 0) | |
| atan | Returns inverse tangent | (atan 1.55741) | 1 |
| atan2 | Two arguments arctan function | (atan2 1 1) | 0.7853981634 |
| pow | Returns a^x | (print (pow 5 2)) | 25 |
| ceil | Returns ceil of a given reference | (print (ceil 2.3)) | 3.0 |
| floor | Returns floor of a given reference | (print (floor 2.3)) | 2.0 |
| round | Returns round of a given reference. (nearest integer) | (print (round 2.3)) | 2.0 |
| isinf | Returns 1 if the given reference is either negative or positive infinitive else returns 0 | (print (isinf (/ 19 0))) | 1 |
The table shown above is hopefully enough to introduce our functions in the math package. Any Fuzuli program should include the math package using the (require) expression if any math function shown above is planned to use. Look at the code below:
(require "/usr/lib/fuzuli/nfl/math.nfl") (print (isinf (/ 19 0)))
Although math functions are collected in an external package, Fuzuli supports built-in arithmetic functions. The code shown below is calculating ordinary least squares regression coefficients. As you see, no math functions required and only the arithmetic functions are used.
(let x (list 1 2 3 4 5 6 7 8 9 10))
(let y (list 10 20 30 40 50 60 70 80 90 100))
(function sum (params a)
(block
(def s FLOAT)
(def i INTEGER)
(let s 0.0)
(for (let i 0) (< i (length a)) (inc i)
(let s (+ s (nth a i)))
)
(return s)
)
)
(function mean (params a)
(block
(def total FLOAT)
(def result FLOAT)
(let total (sum a))
(let result (/ total (length a)))
(return result)
)
)
(function covariance (params c d)
(block
(def meana FLOAT)
(def meanb FLOAT)
(def xy FLOAT)
(def i INTEGER)
(let meana (mean c))
(let meanb (mean d))
(let xy 0.0)
(for (let i 0) (< i (length a)) (inc i)
(block
(let xy (+ xy (* (- (nth c i) meana) (- (nth d i) meanb ))))
)
)
(return xy)
)
)
(let beta1 (/ (covariance x y) (covariance x x)))
(let beta0 (- (mean y) (* beta1 (mean x))))
(print "beta0 " beta0 "\n")
(print "beta1 " beta1 "\n")
The result is 0.0 for beta0 and 10.0 for beta1.
See you in next entry. Have fun!
Wednesday, May 30, 2012
Defining variables and variable scopes in Fuzuli
Fuzuli has a basic variable scoping strategy and it is easy to understand. Many Algol family languages support variable types, variable defining, initial value setting and updating values. Internally, everything in Fuzuli is a Token. A Token is a C++ object. It can hold an INTEGER, a FLOAT, a STRING, a LIST of all types and a COBJECT. Variables are basically type of an INTEGER, a FLOAT or a STRING. A Fuzuli LIST is a vector or array of those kind of objects. A LIST may be a member of an other LIST. So, objects in Fuzuli can be recursively deep. A COBJECT is a (void*) pointer and can be anything. This type of variable is used for external function calls, usually from C++ or C libraries such as Math, IO and MySQL. Integration of COBJECT types expands the universe that Fuzuli can access. However, a standard user does not need this kind of object because Nafile (nfl) packages wrap those external function calls.
We use (let) expression to set value of a variable in Fuzuli:
# Value of a is set to 10 (let a 10) # a is now 20 (let a 20) # a is now a string (let a "Hello!") # a is now a double precision number (let a 3.141592)
(block) expression defines a block in which variables are locally scoped. If a variable defined in a higher scope, it is current in the child scope. In other terms, if a variable set in a deeper scope but it is first defined in the higher scope, the first defined variable is current. Have a look at the example below:
# Value of a is set to 10 # a is defined in higher level (let a 10) # this block defines a deeper (local) scope (block (let a 20) ) # out of the block, a is 20 because global a is accessed from the local scope (print a) # the answer is 20
However, one can want to define a local variable with same name of the higher scoped variable. For this, (def) expressions can be used. Look at the example below:
# Defined in an higher scope (let a 10) # deeper scope (block (def a NULL) (let a 7) ) # we are in higher scope again (print a) # the answer is 10.
So, in Fuzuli, a user does not need to define variables if they want to give a reference them. Look at the (for) expression given below:
(let i 5)
(for (let i 0) (< i 10) (inc i)
(block
(print "i is " i "\n")
)
)
(print "Finally, i is " i "\n")
The output is
i is 0 i is 1 i is 2 i is 3 i is 4 i is 5 i is 6 i is 7 i is 8 i is 9 Finally, i is 10
because, i is first defined in a higher level of scope. If i is not defined before the (for) expression, the code should be like this
(for (let i 0) (< i 10) (inc i)
(block
(print "i is " i "\n")
)
)
(print "Finally, i is " i "\n")
and the output is
i is 0 i is 1 i is 2 i is 3 i is 4 i is 5 i is 6 i is 7 i is 8 i is 9 Finally, i is NULL
because i is defined locally and it is invisible in the higher scope. Strategy of variable scoping in function calls is an other special issue in Fuzuli Suppose that we have an (sum) function defined as follows:
(function sum (params x)
(block
(def t FLOAT)(def i FLOAT)
(let t 0.0)
(foreach i in x
(let t (+ t i))
)
(return t)
)
)
In the example above, the (sum) function takes a list 'x' as parameter and returns the sum of elements of this list. The variable 't' is defined and set in the function body. This is unnecessary if we don't use a variable with name 't' in the higher level of scopes. For convenience and security, defining all local function variables before they were used is a good habit. For the rest of the example, the sum function can be called using
(let mylist (list 1 2 3 4 5)) (let result (sum mylist)) (print result "\n")and gives the result of 15. Hope you have fun !
An informative video on RCaller
It is nice to see RCaller has an higher usage rates after its 2.0 version.
You can see the embedded video in this entry. Have a nice training!
Writing CGI scripts with Fuzuli Programming Language
Fuzuli has a different approach for CGI scripts. For example, in Php, a script file has a file extension of .php and it must be started with some html tags or a php starter
<?php
tag. While the file extension is .php, we have to declare that "we have finished writing html codes and now we are starting a new php area!". However, in Fuzuli, the default behavior is to write fuzuli code and writing html is an exception.
A fuzuli cgi script must define the location of the interpreter in the top level of the code:
#!/usr/bin/fuzuli
Secondly, before writing any output, content-type should be defined :
#!/usr/bin/fuzuli (print "Content-type: text/html\n\n")
Ok. That is too much naive to CGI scripters. How to add html tags to this script? Follow the example below:
#!/usr/bin/fuzuli (print "Content-type: text/html\n\n") <?html <h1>Hello World!</h1> ?>
Very nice, hah? So we can easily combine our logic and html! Ok lets do some html forms and handle them in Fuzuli.
#!/usr/lib/fuzuli/fuzuli
(print "Content-type: text/html\n\n")
<?html
<form method="get">
Enter your name:
<input type="text" name="name">
<input type="text" name="email">
<input type="submit" value="Click">
</form>
?>
(let name (REQUEST "name"))
(let email (REQUEST "email"))
(if (isset name)
(print "Posted name is : " name)
)
<?html
<h1>-----------------</h1>
?>
(if (isset email)
(print "Posted email is: " email)
)
In the example above, the name and the email variables are sent from the html form. If they are set, their values are printed. Very simple. A Fuzuli loop can include an html block so one can generate html codes efficiently. Look at the code below:
#!/usr/lib/fuzuli/fuzuli
(print "Content-type: text/html\n\n")
<?html
<table border = "1">
?>
(let days
(list "sunday"
"monday"
"tuesday"
"wednesday"
"thursday"
"friday"
"saturday"
)
)
(for (let i 0) (< i (length days)) (inc i)
(block
<?html <tr><td><b> ?>
(print i)
<?html </b></td>
<td><i>
?>
(print (nth days i))
<?html
</b></td></tr>
?>
)
)
<?html
</table>
?>
Fuzuli supports cookie operations internally. setcookie and getcookie functions were implemented for setting and getting cookies, respectively. Note that cookies must be set before sending the content-type header.
setcookie (var "This is cookie value") (let value (getcookie "var"))
The next step is to implement session functions. We are still discussing the session structure of Fuzuli. It seems it is the most convenient method to implement this functionality in Nafile (nfl) packages. Hope you like scripting with Fuzuli...
Subscribe to:
Posts (Atom)