Scilab is interoperable. You can use Scilab from other applications, or integrate your components written in other languages in Scilab:
- Extend Scilab with other languages: Java, Python, Tcl Tk, Fortran or C, C++,
- Use Scilab from Java, Python or C, C++ external application to perform calculations,
Other languages use in Scilab
Scilab, an extensible platform. To reuse previously developed code and applications, Scilab can be extended with Java, Python, TCl, Fortran or C/C++ components. Some details on how it can be done:
JIMS module (Java Interaction Mechanism in Scilab) allows Scilab to instantiate Java objets. Thus, without any recompilation needed, Scilab is able to integrate and use your classes and interact with applications developed in Java.
For example, from Scilab, a Java object can be used as easily as:
jimport('myPackage.HelloWorld'); object = HelloWorld.new(); object.message();
JIMS is included in Scilab since 5.5.0 version.
Just as with Java, Scilab is able to interact with any code written in Python thanks to its PIMS module.
Through an interconnection with Python interpreter, Scilab calculation engine can exchange transparently while using Scilab data types to code written in Python. This extension intrinsically supports Python advanced data structures (Dict, Set, Tuple, etc.) but also Numpy ones.
For example, the following Scilab code makes a call to "math" Python package and call the "eye" function:
pythonMath = pyImport("math", %f) a=pythonMath.ceil(2.5); a == 3
PIMS is an output of OASIS R&D project, funded by Systematic Paris-Région competitiveness cluster.
Included in the official distribution of Scilab, Scilab software offers easy access to Tcl and Tk features. The functions enable to exchange variables between Scilab <=> Tcl interpreters, to execute Tcl / Tk scripts and to pilot control GUIs developed in Tk.
b=[6,4,1;2,3,5]; TCL_SetVar("B",b) BfromTCL=TCL_GetVar("B")
C, C++, Fortran
Embedded into Scilab, api_scilab provides an easy and fully tested API to link any C or C++ code in Scilab interpreter. Through this API, any library can be loaded and its features proposed into the Scilab language itself. Within the Scilab environment, this allows the creation of full workflows while keeping the same datatypes in the same application without any complex linking phase.
Call Scilab from other languages
Scilab can be used as a standalone calculation engine. Thus, all Scilab features can be called by external applications. To meet all users needs and simplify its adoption, connectors are available.
Java is a major programming language and Scilab should offer a Java interface.
Javasci provides a simple and documented API which follows the Java conventions to use Scilab engine features from a Java application or library. Fully and automatically tested, it allows any application to delegate the calculation and modeling parts to Scilab.
For example, the following Java code shows the data exchange between Java and Scilab engine and a simple calculation:
Scilab sci = new Scilab(); sci.open(); sci.exec("disp(%pi);"); ScilabDouble a = new ScilabDouble(3.14); sci.put("a",a); sci.exec("b=sin(a);"); ScilabType b = sci.get("b"); System.out.println("b = " + b);
The lastest improvements of Javasci come from Similan R&D project.
Sciscipy, originally developed by Vincent Guffens, extends Python by providing all the features of Scilab. Thus, since the Python interpreter, it is possible to access seamlessly any Scilab function.
For example, the following Python code shows the call to Scilab function for generating random numbers rand () use to create a matrix of size 20x20 and then performs some simple calculations on this data:
from scilab import Scilab sci = Scilab() x = sci.rand(20, 20) y = x*x.transpose() y_inv = sci.inv(y)
Sciscipy transparently manage data conversions (both Python and Numpy types).
Like javasci, call_scilab offers from C or C++ code, an API to access Scilab engine. With this feature, Scilab can be instantiated to delegate calculation issues. From the C/C++, call_scilab provides functions to send tasks to Scilab and api_scilab providing functions for reading and writing Scilab variables via their names.
Connection with other applications
Scilab can be called from your favorite applications through dedicated modules, gateways or inner components.
Scilab can read data from Excel and write data in Excel spreadsheets thanks to a dedicated external module. xls link is available via ATOMS.
Thanks to Scilab XLL external module, users can call Scilab from Excel and get the Scilab results back to Excel spreadsheet.
Using macros in Excel is like using Scilab functions. Scilab gives users the possibility to import data from Excel to Scilab (with xls link module for example). Users can then convert their Excel-macros in using Scilab equivalent functions.
Excel® is a trademark of Microsoft Corporation
Scilab Enterprises offers dedicated components for Isight (Dassault Systèmes flagship software). Thus, Scilab features are available through a component called "Activity" which is able to execute code or a Scilab function taking as input any Isight feeds and returning the results from Scilab calculation.
In parallel, an "Optimization" component is available to simplify access to Scilab advanced features in the field of models optimization. Thanks to this component, pre and post processing are performed in an integrated, simple and effective way.
Connecting LabVIEW with Scilab…and getting Scilab’s power through LabVIEW With the LabVIEW to Scilab Gateway, access to the most used open source platform for numerical computation in the world and enjoy the best of the two products. The software that provides a link between LabVIEW and Scilab allows you to easily invoke your Scilab Scripts from your LabVIEW Virtual Instruments (VIs).
Download the LabVIEW to Scilab Gateway Version 1.2 Software Requirements Windows XP/Vista/7 Scilab 5.3.0 (or later) LabVIEW 8.0 (or later)
ProActive Parallel Suite is an innovative Open Source solution (OW2) for parallel, distributed, multi-core computing.
Accelerate Scilab with ProActive Parallel Suite: Parallel Computations on Multi-Cores, Desktops, Clusters & Cloud
ProActive seamlessly allows to execute Scilab applications in parallel on all types of infrastructures. Execute today on a set of desktop machines, tomorrow on enterprise servers, and in the future on external Clouds, without changing your code.
ProActive handles heterogeneous Resource Management (Linux, Windows, MacOS), scheduling with fault-tolerance, together with Graphical User Interface.
To use easily Proactive Parallel Suite from Scilab, you can download ProActive Cloud Connector ATOMS module
Scilab is a useful environment in the context of HPC, allowing the simple development of applications. However, when application data grows, the lack of parallel constructs limits its use for real cases.
Hence, the goal is to have an interface with DIET that can distribute Scilab tasks on several nodes over Grids or over Cloud platforms.
Prerequisites Linux DIET 2.7 Scilab 5.3.0 (or later) Classical gcc compiler suite libstdc++6.1.15