Javascript and Fuzuli Integration

JFuzuli, the Java implementation of Fuzuli Programming Language now supports limited Javascript integration.

JFuzuli currently supports passing Fuzuli variables to Javascript environment, passing Javascript variables to Fuzuli environment, embedding Javascript code in any part of a Fuzuli source code.

The full support is planned to have ability of calling Fuzuli functions directly from within Javascript.

Here is the examples. This is the simplest one to demonstrate the basic usage of Javascript support:

In the example above, the variable a is set to 10 in Fuzuli part, is incremented by 1 in Javascript part and is printed in the Fuzuli part again. After all, value of a is 11.

In the example above, the variable message is first defined in Javascript section and was null in Fuzuli section at the top. And also, it is clear that the variable message is defined using the var keyword in Javascript section. After all, at the Fuzuli section, message is printed with its value which was set in Javascript section.

The example above is more interesting as it has a function which is written in Fuzuli language, but the function has its body written in Javascript! In this example, square function has a single parameter x. x is then passed to Javascript body and the result is calculated. Value of result is then returned in Fuzuli. At the end, the Fuzuli function call  (square 5) simply returns 25 which is calculated by Javascript.

Passing Arrays 

Because the list object in Fuzuli is simply a java.util.ArrayList, all public fields and methods of ArrayList are directly accessable in Javascript section. Look at the example below. In this example a list object is created with values 1,2 and 3, respectively. In Javascript section, the values of this object is cleaned first and then 10 and 20 are added to the list. Finally, in the Fuzuli section, object is printed only with values 10 and 20.

List objects can be created directly in Javascript section. Look at the example below. Since JFuzuli interpreter uses the javax.scripting framework, a Java object can be created with new keyword. The variable a is a list object in Fuzuli section again and the printed output includes two values of 10 and 20.

You can try similar examples using our online interpreter in url 

http://fuzuliproject.org/index.php?node=tryonline

Hope you get fun with Fuzuli...

Passing Fuzuli Expressions to Functions

Fuzuli Programming Language has many features borrowed from many popular languages such as C and Java as well as Lisp and Scheme.

It is known that a function pointer can be passed to a function in C and C++, whereas, we must declare the structure of a function using interfaces for doing same job in Java.

In Fuzuli, a Fuzuli source code can be directly passed to a function. This feature allows us to create generic functions easly. Let's show it using an example.

The code below creates four expressions that sum, subtract, product and divide two numbers, respectively.

(let expr1 (expression (+ a b)))
(let expr2 (expression (- a b)))
(let expr3 (expression (* a b)))
(let expr4 (expression (/ a b)))

The expression directive defines a runnable code using the directive eval as we will see later. Let's define a generic function that changes its behaviour respect to a expression parameter:

(function generic_function (params e x y)
   (let a x)
   (let b y)
   (return (eval e))
)

The function generic_function takes three parameters. The first one defines the real action. x and y are parameters that will be passed to expression later. Let's call this generic function using previously defined expressions:

(let enter "\n")
(let x1 15)(let x2 5)
(print "x1=" x1 ", x2=" x2 enter)
(print "+ : " (generic_function expr1 x1 x2) enter)
(print "- : " (generic_function expr2 x1 x2) enter)
(print "* : " (generic_function expr3 x1 x2) enter)
(print "/ : " (generic_function expr4 x1 x2) enter)

In first line we define the enter variable for printing output with line feed. In second line, we set x1 to 15 and x2 to 5. In third line, we are reporting the values of these variables.

The whole story lies at last four lines. In line four, we are calling the function generic_function using the predefined summation expression. In the next line, the same function is called using a different expression which calculates x1 - x2 . As it is clear to see that, last two lines calls the same generic function using two different expressions for getting the product and division of two numbers, respectively.

The output is :

x1=15.0, x2=5.0
+ : 20.0       
- : 10.0       
* : 75.0       
/ : 3.0        



Happy readings...


Notes:

You can try this code using the online interpreter: http://fuzuliproject.org/index.php?node=tryonline
or you can download the JFuzuli Editor: http://mhsatman.com/fuzuli-programming-language-facebook-face/

Fuzuli Programming Language and Editor

Our programming language, Fuzuli, now has a new interpreter written in Java which is officially called JFuzuli.

You can try it online at site http://fuzuliproject.org/index.php?node=tryonline

We also get our first JFuzuli Editor ready for downloading at https://drive.google.com/file/d/0B-sn_YiTiFLGRHdVSUQ2cFZyT0U/edit?usp=sharing

Please feel free and do not hesisate to share your thoughts about the language and the interpreter.

You can also visit the Facebook page which is aimed to inform Turkish users using the address https://www.facebook.com/FuzuliProgramlamaDiliVeYorumlayici?ref=hl

RCaller 2.4 has just been released

The key properties of this release:

• Added deleteTempFiles() method in class RCaller for deleting temporary files that are created by RCaller at any time. 
• runiversal.r is now more compact
• StopRCallerOnline() method in class RCaller now stops the R instances in the memory which are created in runAndReturnResultOnline(). Click to see the example for RCaller.stopRCallerOnline() method.

The next release 2.5 will be submitted in 15th July 2014.


Get informed using the formal blog http://stdioe.blogspot.com.tr/search/label/rcaller

 Download page: https://drive.google.com/?authuser=0#folders/0B-sn_YiTiFLGZUt6d3gteVdjTGM

 Source code: https://code.google.com/p/rcaller/

 Home page: http://mhsatman.com/tag/rcaller/

 Journal Documentation: http://www.sciencedomain.org/abstract.php?iid=550&id=6&aid=4838#.U59D8_mSy1Y

R GUI written in Java using RCaller

This video demonstrates how the Java version of R GUI based on RCaller is now faster after the speed improvements. This simple gui is available in the source tree. Typed commands are passed to R using the online call mechanism of RCaller and there is a single active R process at the background. 

Please follow the rcaller label in this blog site to achive latest RCaller news, updates, examples and other materials. 

Have a nice watching!