Home

Rturbo/P is a dialect of the S language and its relative R. It aims at high performance statistical computing and stochastic simulation and is implemented as a lightweight and portable compiler. Rturbo/P is significantly faster than R and implements easy to use extensions for parallel multi-core computing and cluster computing. The system is available for free for various architectures and operating systems such as OS X, Windows, Linux and Raspberrry Pi (ARM)

Upcoming features:

• Functions for encryption and hash generation
• Support for basic image analysis using the C++ CImg library by  on-the-fly compilation and linking.

News:

• New version 2015_03 released
• Improved file I/O and string handling
• New simple interface to run P scripts from C
• Reading and writing of .wav audio files implemented
• Parallel computing: parallel for, cluster computing using fork
• Communication via sockets available
• Simple and elegant OO model
• Ported to the Raspberry Pi (ARM)

Rturbo/P...

• is really fast! 
• compiles a basic subset of the R language for statistical computing
• provides tremendous speedups of existing code written in R and S
• is our blueprint for the next generation statistical computing using the R language
• easy to use and very similar to R
• can be embeded into other languages and apps such as R, C/C++ and JAVA.

 If you know a faster way to run R programs, let us know!

About

Rturbo/P is a standalone compiler for the P language, a subset of the well known R language for statistical computing and data analysis, extended by various functionalities for parallel programming, simplified porting of algorithms written in C/C++ and simplified formulation statistical formulas.

R is the de-facto standard in statistical computing, stochastic simulation and data analysis. However, when implementing new algorithms in R, the resulting code can be very slow, since R is not a compiled language. 

Since most time-critical computational tasks can be implemented using only a small subset of R, the P compiler does not intend to provide full coverage of the R language. However, the most important object types, namely vectors, matrices, and lists are implemented and basic operations for them. Since P code can be easily embedded into R programs, this represents no real constraint. In this way, one has the best from both worlds.

P implements elegant and easy to use extensions for parallel (concurrent) programming aiming at the functionalities a statistician realy needs. Right from the beginning, the P core computing engine was designed to allow for a simple solution to multi-core statistical computing. The runtime engine is thread-safe and, indeed, the engine calls itsef recursively.

Rturbo/P is our blueprint for a next generation R. 

The Rturbo/P compiler and the runtime system has been developed by Ansgar Steland, Professor at RWTH Aachen University, in his spare time. All intellectual properties (IP) are hold by Ansgar Steland, Aachen, Germany. 

Key Features

• Rturbo/P runs on Windows (XP, 7), Apple (OS X) and Linux.
• Rturbo/P for Windows is a small standalone system that does not require other software to be installed.
• Rturbo/P is compatible with RStudio.
• There are no system limits for the size of objects (matrices, vectors, lists) - even in the demo version. The limits are your OS and your hardware.
• The standard libraries provide basic functions for statistical analysis and numerics. Particularly, the current version implements (simplified versions of) elementary statistical functions such as mean, sd, quantile, summary as well as more advanced basic functions such as  lsfit, svd, qr, solve and chol. Some time series are also implemented.
• Implementing algorithms for languages such as C of JAVA is simplified by the cstyle environment, where vectors and matrices are indexed as in C, and C-like function definitions. P also implements a C-like for loop.
• Parallel threads can be easily written using the thread statement.
• Parallel for loops allow simple parallel computations and simulations.
• Local threads within a function can use local variables as private variables or shared variables. They can even call that function recursively.
• Simple parallel cluster computing is possible with fork.
• Rturbo/P supports default expressions for arguments as well as named arguments
• Socket communication is implemented. All currently supported data types and structures including lists can be transmitted easily.
• Basic support for strings and boolean is available.
• C-like I/O capabilties including simplified versions of snprintf, fprintf are available. 
• P implements a JAVA-like easy-to-use object system with simple inheritance

Benchmarks

The following benchmarks show that P can provide substantial speedups compared to interpreted R as well as R's byte code compiler.

The benchmarks demonstrate that you can expect speedup factors between 10 and 40 when using P instead of R for your own algorithms. Even internal vectorized computations and internal functions usually run much faster. When studying the benchmarks given here you will encounter one example where P runs 125 times faster than R.

 The results are obtained using R 2.13 and P 2011_06 for OS X 10.6.

- to be continued -

1 Simple expression in loops

Dirk Eddelbuettel has studied the performance of R 2.13 and the attached byte code compiler of Luke Tierney, when calculating the expression 1/(1+x) many times. This is, of course an artifical example, but it is good for comparison. He reports that the byte code compiler of R provides speed up factors of 3 - 5.

Let us compare the performance of interpretated R and P.

Here is the shortened R code:

f <- function(n, x=1) for (i in 1:n) x=1/(1+x)
h <- function(n, x=1) for (i in 1:n) x=(1+x)^(-1)
 ## now load some tools
library(rbenchmark)

# now run the benchmark
N <- 1e6
benchmark(f(N,1), h(N,1),
          columns=c("test", "replications", "elapsed", "relative"),
          order="relative", replications=10)

I ran that code on my laptop (dual core, 2.4GHz)

     test replications elapsed relative
1 f(N, 1)           10  12.558 1.000000
2 h(N, 1)           10  18.150 1.445294

Averaged over 10 repetitions, R needs 12.558 seconds to calculate 1/(1+x) one million times and 18.150 seconds for (1+x)^(-1).

Let us look how P performs. Here is the equivalent P code:

f <- function(n, x=1) { var i; for (i in 1:n) x=1/(1+x); return(0) }
g <- function(n, x=1) { var i; for (i in 1:n) x=(1+x)^(-1); return(0) }

N = 1e6
repetitions = 10
i = 0

tm = time   # gives time in seconds
for ( i in (1:repetitions) ) call f( N, 1 )
print( time-tm )
tm = time
for ( i in (1:repetitions) ) call g( N, 1 )
print( time-tm )

P needs only 1.29 seconds for function f and 1.59 seconds for g! This is a speed up factor of 9.73 and 11.4. The Professional Edition with code optimization only needs 0.89 and 1.05 seconds corresponding to a speedup factor of 14.1 and 17.2, respectively.

2 Path-dependent loops

Here is second benchmark mainly dealing with array indexing and loops taken from here. The code is as follows:

library(inline)
library(rbenchmark)
library(compiler)

fun1 <- function(z) {
  for(i in 2:NROW(z)) {
    z[i] <- ifelse(z[i-1]==1, 1, 0)
  }
  z
}
fun1c <- cmpfun(fun1)

fun2 <- function(z) {
  for(i in 2:NROW(z)) {
    z[i] <- if(z[i-1]==1) 1 else 0
  }
  z
}
fun2c <- cmpfun(fun2)
z <- rep(c(1,1,0,0,0,0), 100)
identical(fun1(z),fun2(z),fun1c(z),fun2c(z))
 
res <- benchmark(fun1(z), fun2(z),
                  fun1c(z), fun2c(z),
                  columns=c("test", "replications", "elapsed", "relative", "user.self", "sys.self"),
                  order="relative",
                  replications=1000)
print(res)

I ran this code on my laptop (2.4Ghz, dual core) with the following result:

     test replications elapsed  relative user.self sys.self
4 fun2c(z)         1000   0.671  1.000000     0.661    0.008
2  fun2(z)         1000   2.720  4.053651     2.704    0.015
3 fun1c(z)         1000  15.330 22.846498    15.131    0.186
1  fun1(z)         1000  17.584 26.205663    17.241    0.263

Let us focus on fun2, the faster version. The equivalent P code is as follows:

source('stdlib.P')
fun2 <- function(z) {
  var i;
  for(i in 2:nrow(z)) {
    z[i] <- if (z[i-1]==1) 1 else 0
  }
  return(z)
}

tm = time
z = c()
i = 0
for ( i in (1:100) ) z = c( z, c(1,1,0,0,0,0) )
repetitions = 1000
i = 0
for ( i in (1:repetitions) ) call fun2( z )
print( time-tm )

(rep is implemented, but currently only to repeat scalars, sorry.)

P needs only 0.14 seconds to compute fun2 on z. This is a speedup factor of 2.7 / 0.138 = 19.28 compared to interpreted R and 0.671 / 0.14 = 4.79 compared to R's byte compiler.

When comparing with fun1, which is much slower in R and needs 17.58 seconds, the speedup factor is 17.58 / 0.14 = 125!

3 Singular value decomposition

Singular value decomposition is a build-in function in R as well as P. Let us examine how long it takes to compute 1000 Hilbert matrices of dimension 9 and the corresponding SVD decomposition.

Here is the R code:

hilbert <- function(n) { i <- 1:n; 1 / outer(i - 1, i, "+") }

svd.test = function() {
X <- hilbert(9)[,1:6]
s <- svd(X)
D <- diag(s$d)
return(D)
}

svd.test.c = cmpfun(svd.test)

res <- benchmark( svd.test(), svd.test.c(),
                  columns=c("test", "replications", "elapsed", "relative", "user.self", "sys.self"),
                  order="relative",
                  replications=1000)

The result is

         test replications elapsed relative user.self sys.self
2 svd.test.c()         1000   0.299 1.000000     0.283    0.016
1   svd.test()         1000   0.360 1.204013     0.284    0.014

R needs 0.36 seconds and the compiled version 0.299.

The P program looks a bit different, but not much:

source('stdlib.P')

hilbert.plus = function( x, y ) { var ; return( x+y ) }
hilbert = function( n ) {
  var i;
  i = 1:n
  return( 1/outer( i-1, i, hilbert.plus  ) )
}

svd.test = function() {
  var X, s, D;
  X <- hilbert(9)[,1:6]
  s <- svd(X)
  D <- diag(s$d)
  return(D)
}

repetitions = 1000
tm = time
i = 0
for ( i in (1:repetitions) ) val = svd.test()
print( time-tm )

Using P it takes only 0.106 seconds. This means, even in this, where most of time-consuming computations are done internally by the system, P runs 3.4 times faster than R and 2.82 times faster than R's byte compiler.

The Professional Edition needs 0.079 seconds. This is a speedup of 4.56 compared to R and 3.78 times faster than R's byte code.

4 Fractional Brownian Motion

The following P program, which can be easily ported to R, implements a standard algorithm to simulate a fractional Brownian motion on a grid of time points.

source('stdlib.P')

# returns a matrix with d rows
# each row is a simulated trajectory of fractional Brownian
# motion with parameter H

sim_fBM <- function( grid, H , d ) {
  var H2, N, traj, C, i, j, L, k, x;

  H2 = 2 * H
  N = length( grid ) - 2
  traj = matrix( d, N+1 )
  C = matrix( N+1, N+1 )
  for (i in (1:(N+1))) {
        j = i:(N+1)
        C[i, j] = 0.5 * (abs(grid[i+1]-grid[j])^H2 +
                abs(grid[i]-grid[j+1])^H2 - abs(grid[i] - grid[j])^H2 -
        abs(grid[i+1] - grid[j+1])^H2 )
        C[j, i] = C[i, j]
  }
  L = t( chol( C ) )
  for ( k in (1:d) ) {
        x = rnorm( N+1, 0, 1 )
        traj[ k, ] = L %*% x
  }
  return( traj )
}

fBM_test = function() {
  var i, traj;
  for ( i in (1:10) ) traj = sim_fBM( seq(0,1,0.001), 0.4, 4 )
  return(0)
}

tm = time
call fBM_test()
print( time-tm )

R needs 7.237 seconds and the byte compiler 6.489 corresponding to a speedup factor of 1.12. P's public edition needs 4.028 seconds (speedup factor 1.8) and the Professional Edition 3.8 seconds, that is 1.9 times faster than R.

Even in this example code, where most of computing time is spent in vectorized computations and the internal function which calculates the Cholesky decomposition, P outperforms R substantially.

Documentation

Tutorial

User and Reference Manual

Code Examples 

Parallel simulation:

Using the thread statement: 

Using references (pointers):

  res = mean( x[1:i] )

  n = length( x )

Random Numbers 

Implemented random number generators:

runif( n )

rnorm( n, mean, sd )

rt( n, df )

rchisq( n, df )

rgamma( n, shape, scale )

rbeta( n, shape, scale )

rpois( n, lambda )

rlogistic( n, shape )

rcauchy( n, location, scale )

rinvgamma( n, shape, scale )

All functions are internal. Thus, they have not named arguments.

FAQ

Q: Which features of C can be 
    used in a cstyle environment?

Q: Why are the graphic functions
    of R not implemented?

Q: Can I use a shared library
    written in C++ in P?

Q: How to invoke P from R (many time)?

Download Area

Here you can download free versions of Rturbo/P with various example programs.

Extract the files to a directory of your choice. For further information see below.

Download Rturbo/P 2015_06 for
 

      Linux (Ubuntu 14.04LTS, 64bit, tar.gz archive) 

      RaspberryPi (.zip archive) 

      Mac OS X (64bit, tar.gz archive) 

      Windows 7 (.tar.gz archive) 

A manual will be provided as soon as possible. Meanwhile, please study the example programs to learn what kind of R code you can speedup with P.

Installation Instructions for Windows:

The Rturbo/P system comes as a command line tool as well as a shared library. The standalone compiler is invoked from a Windows command prompt ('cmd.exe') or from MSYS. It complies text files. The current version does not provide an interactive mode. To install P proceed as follows:

1. Download the zip archive.
2. Extract the zip archive to a directory of your choice.
3. Start a command prompt (cmd).
4. Go to the directory Pdemo. Here you find Pc.exe and libgomp-1.dll (which is needed). If libgomp-1.dll is not yet installed on your system, copy it to windows/system32 or to the directory from which you invoke Pc.exe.
5. To run an example program enter, e.g. '.\Pc examples\linear_model.P' 
6. To edit the P programs, you may use notepad, e.g. 'notepad linear_model.P'

Since P programs can be embedded into R programs, you can also use RStudio to edit and run programs. Start RStudio, load example1.R in the examples folder, set the working directory to the source location and run example1.R to see how it works! 

Major Changes and Improvements of Version P2015_06:

• Vectors of strings such as x = c('hello', 'world') implemented. You can access elements as usual, e.g. x[2], but multiindices are not yet implemented (i.e. x[1:2] etc. does not work). Mixing of numbers and strings is not possible (use lists in those cases). Internally, vectors of strings are implemented as in C. Hence, a call such as C_('my_C_function', &x ) allows to feed a C function with an array of strings (as referenced by char **stringarray).
   
• One can now access those command line args following the P source file name using the functions argc(), which returns the number of arguments, and argv(i), which returns the ith argument as a string. Example:
  
    ./Pc -O -nw myprog.P hello world 10
  
  here argc() equals 3 and argv(1) gives 'hello', argv(2) gives 'world' and argv(3) '10'.
   
• Slightly improved and extended standard libraries. 
   

Major Changes and Improvements of Version P2015_03:

• On-the-fly compilation and linkage of C and C++ extensions added (see gcc.P and g++.P in the examples folder), allowing to include the C/C++ sources directly in the P source file. This feature requires that gcc/g++ is installed on the system (mingw/MSYS on Windows systems).
   
• strreplace allows to substitute substrings in a string (see strreplace.P in the examples folder).
   
• for loops can now iterate over the items of a list
   
• Random number generators: rbeta, rgamma, rchisq, rpois, rlogistic, rcauchy, rlognormal, rexp
   
• the system() statement allows to invoke system commands. See gcc.P for an example.
   
• Easy-to-use interface to run P scripts (given as a string or as a text file) from C. See the example in the folder embed_PinC.
   
• Rturbo/P is compiled with gcc/g++ version 4.8 (Linux, Windows) or 4.6 (OS X).

Major Changes and Improvements of Version P2013_11:

• Scope of variables: To improve compatability with R, the scope of global variables has been changed. If a variable exists globally, it can be used inside a function. But an assignment with '=' inside a function does not change its global value. Instead a local variable with the same name is introduced. As a consequence, P has now the same behavior as R. If you want set a global variable inside a function, use <<- (as in R).

• The system libraries stdlib.P and stdmath.P are now automatically included. If you want to work with modified versions, one can simply add corresponding source statements.
   
• One may now omit the return statement in a function definition. In this case, a return( NULL ) is automatically added. This means, functions with no return statement return the special value NULL. 
   
• In strings special characters such as \n or \t can now be used. For instance,
  
    cat( 'Hello, 2 * 2 is equal to ' + 2*2 + '.\n\nBye!' )
  
  does now what it is expected to do.
   
• The syntatic shortcut '.(' for a function definitions has been introduced. Instead of
  
    sq = function( x ) return(x*x)
  
  one may write
  
    sq = .( x ) return(x*x)
  
  or
  
    sq <- .( x ) return(x*x)
  
  which sometimes improves the readibility (and looks more mathematical).
   
• The example oo.P on object oriented programming has been polished and should now give a clear picture how the object system works.

Major Changes and Improvements of Version P2012_11:

• Tentative version of fprintf, fscanf and sscanf added (see files3.P for an example).
• Parallel for loop added.
• Some minor bug fixes, closing a memory hole when calling repeatedly from R.

Major Changes and Improvements of Version P2012_10:

• Optimizations for array indexing improved.
• fread/fwrite/filelength added.
• Improved fork() functionality for parallel cluster computing.
• Ported to Raspberry Pi (ARM).

Major Changes and Improvements of Version P2012_08:

• Communication via sockets added.
• Parallel cluster computing via fork() added.
• All version require core2 cpus or equivalent.

Major Changes and Improvements of Version P2012_05:

• Interface (libP) revised ensuring stable JAVA integration.
• The OSX port is now compiled with gcc-mp-4.3, since later versions have a bug such that libP can not be used within RStudio.

Major Changes and Improvements of Version P2012_03:

• Local variables are now detected automatically. The var statement in a function is no longer required.
• If the return statement of a function is missing, return( NULL ) is automatically added.
• Improved I/O functionalities (reading and writing of files)
• A lot of small bugs have been fixed.
• The system now can be used with RStudio.
• New release for OS X.

Major Changes and Improvements of Version P2011_06:

• Support for strings added.
• Support for type boolean added.
• Default expressions for function arguments supported.
• JAVA-like object system (Pro)

Additional Notes

• The compiler has been carefully developed and tested. However, there may still be bugs and it does not provide a full implementation of R. Please take the example programs as starting points for your own experiments.
• Both he compiler and the runtime system perform usually no checks. In particular, there are no out-of-range checks when working with vectors and matrices.
• In the directory embed_R you find an example how to embed P into R programs. 
• In the directory example_shared you find examples which demonstrate how to load dynamically a shared library with functions written in C and C++, respectively.

Projects with Rturbo/P

Member Login

Members Area

#CMSimple $output.=memberspage('Members Area','1,2');#

This page is only for registered users. Please login

Here you can download the unrestricted version of P

P_2015_03 for Linux (Ubuntu 14.04, 64bit:)    download tar.gz archive.

P_2015_03 for RaspberryPi                            download tar.gz archive.

P_2015_03 for OS X:                                       download zip archive.

P 2015_13 for Windows:                                  download zip archive.

older version (probably no longer working:)

P 2012_11 for Windows XP:               download zip archive.

P 2012_11 for Windows 7:                  download zip archive.

P 2012_11 for OS X:                             download zip archive.

P2012_11 for Ubuntu 11.04, 32bit:    download tar.gz archive. 

P2012_11 for Ubuntu 12.04, 64bit:    download tar.gz archive.

P2012_11 for ARM Raspberry Pi (wheezy):    download tar.gz archive.

P 2012_10 for Windows XP:       download zip archive.

P 2012_10 for OS X:                  download zip archive.

P2012_10 for Ubuntu 11.04:    download tar.gz archive.

older versions:

Windows version 2012_08 with extended licence (only exe and lib file): Pc.exe  libP.dll

#CMSimple $output.=memberslogin();#

Acknowledgments

Rturbo/P has been developed using free software, particularly the GNU C compiler gcc. The author greatly acknowledges the work of those who have contributed to the gnu system, particularly the work of Richard Stallman, although he has a slightly different view on various issues. Rturbo/P uses the Mersenne Twister random number generator developed by M. Matsumoto.

Contact

Datenschutz

Ihre personenbezogenen Daten werden vertraulich und entsprechend der gesetzlichen Datenschutzvorschriften sowie dieser Datenschutzerklärung verwendet.

Die Nutzung unserer Webseite ist in der Regel ohne Angabe personenbezogener Daten möglich. Soweit auf unseren Seiten personenbezogene Daten (beispielsweise Name und E-Mail-Adressen für Member-Login) erhoben werden, erfolgt dies stets auf freiwilliger Basis. Diese Daten werden nicht an Dritte weitergegeben.

Die in unseren Apps erhobenen personenbezogenen Daten werden nur für die Funktionalität der App (Benachrichtigung von Personen) erhoben, ausschließlich in der App gespeicher und nicht an Dritte weitergegeben.

Wir weisen darauf hin, dass die Datenübertragung im Internet (z.B. bei der Kommunikation per E-Mail) Sicherheitslücken aufweisen kann. Ein lückenloser Schutz der Daten vor dem Zugriff durch Dritte ist nicht möglich.

Quellverweis: https://www.e-recht24.de

Impressum

Angaben gemäß § 5 TMG

Ansgar Steland
Soerser Winkel 41
52070 Aachen
Kontakt:

Telefon: 2414638230
E-Mail: ast_shopping@ptechnologies.org
Internetadresse: www.ptechnologies.org

Verantwortlich für den Inhalt nach § 55 Abs. 2 RStV:

Ansgar Steland

Haftungsausschluss

Haftung für Inhalte
Die Inhalte unserer Seiten wurden mit größter Sorgfalt erstellt. Für die Richtigkeit, Vollständigkeit und Aktualität der Inhalte können wir jedoch keine Gewähr übernehmen. Als Diensteanbieter sind wir gemäß § 7 Abs.1 TMG für eigene Inhalte auf diesen Seiten nach den allgemeinen Gesetzen verantwortlich. Nach §§ 8 bis 10 TMG sind wir als Diensteanbieter jedoch nicht verpflichtet, übermittelte oder gespeicherte fremde Informationen zu überwachen oder nach Umständen zu forschen, die auf eine rechtswidrige Tätigkeit hinweisen. Verpflichtungen zur Entfernung oder Sperrung der Nutzung von Informationen nach den allgemeinen Gesetzen bleiben hiervon unberührt. Eine diesbezügliche Haftung ist jedoch erst ab dem Zeitpunkt der Kenntnis einer konkreten Rechtsverletzung möglich. Bei Bekanntwerden von entsprechenden Rechtsverletzungen werden wir diese Inhalte umgehend entfernen.

Haftung für Links

Unser Angebot enthält Links zu externen Webseiten Dritter, auf deren Inhalte wir keinen Einfluss haben. Deshalb können wir für diese fremden Inhalte auch keine Gewähr übernehmen. Für die Inhalte der verlinkten Seiten ist stets der jeweilige Anbieter oder Betreiber der Seiten verantwortlich. Die verlinkten Seiten wurden zum Zeitpunkt der Verlinkung auf mögliche Rechtsverstöße überprüft. Rechtswidrige Inhalte waren zum Zeitpunkt der Verlinkung nicht erkennbar. Eine permanente inhaltliche Kontrolle der verlinkten Seiten ist jedoch ohne konkrete Anhaltspunkte einer Rechtsverletzung nicht zumutbar. Bei Bekanntwerden von Rechtsverletzungen werden wir derartige Links umgehend entfernen.

Urheberrecht

Die durch die Seitenbetreiber erstellten bzw. verwendeten Inhalte und Werke auf diesen Seiten unterliegen dem deutschen Urheberrecht. Die Vervielfältigung, Bearbeitung, Verbreitung und jede Art der Verwertung außerhalb der Grenzen des Urheberrechtes bedürfen der Zustimmung des jeweiligen Autors bzw. Erstellers. Downloads und Kopien dieser Seite sind nur für den privaten, nicht kommerziellen Gebrauch gestattet. Soweit die Inhalte auf dieser Seite nicht vom Betreiber erstellt wurden, werden die Urheberrechte Dritter beachtet. Insbesondere werden Inhalte Dritter als solche gekennzeichnet. Sollten Sie trotzdem auf eine Urheberrechtsverletzung aufmerksam werden, bitten wir um einen entsprechenden Hinweis. Bei Bekanntwerden von Rechtsverletzungen werden wir derartige Inhalte umgehend entfernen.