Editing User:Josiah425:TISEAN Package

Jump to navigation Jump to search
User account "Josiah425:TISEAN Package" is not registered. Please check if you want to create/edit this page.
Warning: You are not logged in. Your IP address will be publicly visible if you make any edits. If you log in or create an account, your edits will be attributed to your username, along with other benefits.

The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.

Latest revision Your text
Line 1: Line 1:


= TISEAN Package Porting Project  =
= TISEAN Package Porting Project  =
== Goal of the project ==
The goal of this project is not to port the entire TISEAN package to octave. That would be a desired outcome though it might not be feasible within the time constraints. The goal of this project is to give the TISEAN package a solid start and to port as many functions as possible to create a solid foundation for the future.
== General division ==
== General division ==
As the TISEAN package consists of 74 programs I have divided the first part into three sub-parts:
AS the TISEAN package consists of 74 programs it needs to be divided into subparts that can be tackled separately and create a entity in-and-of-themselves. I chose to work along the lines of the articles about implementations of nonlinear timeseries included in the documentation. This article discusses various algorithms and what certain programs mean. It can be found [http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/chaospaper/TiseanHTML.html| here]. I will discuss in which order I would like to port various topics in this and where my work currently stands.
# FORTRAN ones that can be re-implemented easily in m-files (a good example of such a program is 'henon') -- there are 5 programs in this class
# C programs which also need to be linked to oct files (an example is 'ghkss') -- there are 41 programs in this class
# FORTRAN ones that need to be linked to oct files (an example of such a program is 'project') -- there are 28 programs in this class
They are ordered so that according to my estimates the difficulty rises with the number. This is because typecasting and implicit typing (which is included in most of the FORTRAN files in the TISEAN library) can be problematic sometimes.
 
This number can be brought down significantly. This is because some programs are deprecated, others are just C/FORTRAN copies of each other, others are not important in GNU Octave (such as 'compare' and choose'). After taking the factors above into consideration the number of functions that need to be ported drops to 49. I have prepared a detailed discussion of all of those functions [[User:Josiah425:TISEAN_Package:Table_of_functions| here]]. This number will further drop once certain programs are confirmed to have similar programs in GNU Octave or some packages in Octave Forge.
 
Apart from the qualitative division I propose a work oriented division. In it each subpart can be tackled separately and create an entity in-and-of-itself. I chose to work along the lines of the articles about implementations of nonlinear timeseries included in the documentation. This article discusses various algorithms and what certain programs mean. It can be found [http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/chaospaper/TiseanHTML.html here]. I will discuss in which order I would like to port various topics from this article and where my work currently stands.
==== Nonlinear noise reduction ====
==== Nonlinear noise reduction ====
This is the first topic I chose. It is because it contains programs from all three categories. It is also relatively small -- it contains 3 programs: project, lazy, ghkss. I have chosen to further implement addnoise and henon, to demonstrate how project and ghkss work. Thus this topic contains programs from each category:  
This is the first topic I chose. It is because it contains programs from all three categories. It is also relatively small -- it contains 3 programs: project, lazy, ghkss. I have chosen to further implement addnoise and henon, to demonstrate how project and ghkss work. Thus this topic contains programs from each category:  
Line 19: Line 8:
* Linkable to FORTRAN (project, addnoise, lazy)
* Linkable to FORTRAN (project, addnoise, lazy)
* Linkable to c (ghkss)
* Linkable to c (ghkss)
I have already started working on this stage. My progress can be viewed at [https://bitbucket.org/josiah425/tisean https://bitbucket.org/josiah425/tisean]. So far I have implemented addnoise, project and re-implemented henon as an mfile. As most work on this topic has been completed I estimate that finishing it up will take around 2 days -- throughout my outline I estimate about 1 day per program (that includes documentation and testing).
I have already started work on this stage. My progress can be viewed at [https://bitbucket.org/josiah425/tisean| https://bitbucket.org/josiah425/tisean]. So far I have implemented addnoise, project and re-implemented henon as an mfile. As most work on this topic has been completed I estimate that finishing it up around 2 days -- I estimate 1 day per function (that includes documentation and testing).
 
==== Phase space representation ====
==== Phase space representation ====
This is the next topic that needs to be implemented. This is because it contains programs (especially 'delay') that are used to visualize data. Whenever an example is given in the package the resulting data is routed through 'delay' before it is plotted. Apart from delay it also contains other functions that can divided into the following categories:
This is the next topic that needs to be implemented. This is because it contains programs (especially 'delay') that are used to visualize data. Whenever an example is given in the package the resulting data is routed through 'delay' before it is plotted. Apart from delay it also contains other functions that can divided into the following categories:
* Linkable to FORTRAN (autocorr, pc)
* Linkable to c (delay, corr, mutual, false_nearest, pca)
* Linkable to c (delay, corr, mutual, false_nearest, pca)
There are two more programs in this section of the article they are: 'autocorr' and 'pc', both implemented in FORTRAN. There is no need to port them as according to the documentation ([http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/contents.html here]) they are redundant with other functions. Further more, it is likely 'corr' does not need to be implemented, because 'xcorr' in signal package seems to have similar functionality. This has not been confirmed yet, once that occurs, a definite answer can be given.
Assuming around a day for each function (with testing and documenting the usage) I assume this stage will take a little over a week.
Assuming around a day for each function (with testing and documenting the usage) I assume this stage will take a little under a week.
==== Nonlinear prediction ====
==== Nonlinear prediction ====
This seems like a reasonable next step. It consists of the following programs:
This seems like a reasonable next step. It consists of the following programs:
Line 37: Line 25:
==== Dimensions and entropies ====
==== Dimensions and entropies ====
This topic is next on the list. Programs it include are as follows:
This topic is next on the list. Programs it include are as follows:
* Linkable to FORTRAN (c2, c2t, c2d, c2g, c1)
* Linkable to FORTRAN (c2naive, c2, c2t, c2d, c2g, c1)
* Linkable to C (d2, boxcount)
* Linkable to C (d2, boxcount)
This part of the article also mentions 'c2naive' which is implemented in FORTRAN, but it is also described as redundant by the documentation ([http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/contents.html here])
This stage should take little over a week. I expect this stage and the previous one to take about two weeks.
This stage should take little over a week. I expect this stage and the previous one to take about two weeks.
==== Testing for nonlinearity ====
==== Testing for nonlinearity ====
Line 45: Line 32:
* Linkable to FORTAN (surrogates, randomize , timerev)
* Linkable to FORTAN (surrogates, randomize , timerev)
This stage should take me about 3 days to complete.
This stage should take me about 3 days to complete.
==== Tutorial ====
=== Notes to time estimates ===
I also plan to port all of the functions needed for the four exercises described in the 'Tutorial' section of the documentation. The programs that need to be ported additionally are as follows:
I think my time estimates are rather conservative, but I would rather work on other programs (the documentation contains another article located [http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/docs/surropaper/Surrogates.html| here]) than to be overwhelmed with the work and try to rush trough. As I am not fully familiar with the mathematical concepts discussed within these articles I want to make sure that I reduce the possibility of error when linking programs to octave to a minimum. If I vastly overestimated the time I will need to port those functions I intend to finish the 'Visualization, non-stationary' section of the work on nonlinear timeseries and then proceed to programs from the 'Surrogate time series article'.
* Linkable to FORTRAN (stp)
 
* Linkable to C (ar-model, d2, poincare, recurr, nstat_z)
 
The programs: 'spectrum', 'historgram', 'extrema', 'corr' need to have a confirmed equivalent function in GNU Octave.
This stage should take me about a week.
Porting of the TISEAN package has a couple parts. First part is making the FORTRAN and c programs accessible to Octave. Second part would be creating makefiles and putting all that code in a neat package.
=== Notes on time estimates ===
I have divided the first part into three sub-parts:  
Totaling up the above estimates it should take me 6-7 weeks to complete my task as outlined above.  
# FORTRAN ones that can be re-implemented easily in m-files (a good example of such a program is 'henon')
# the FORTRAN ones that need to be linked to oct files (an example of such a program is 'project')
# c programs which also need to be linked to oct files.
As linking FORTRAN code to oct code is most difficult of those three tasks, there are 28 in this category. If it is more difficult than I expect I will move some of the easier programs into the m-file category.
 
Next there are the programs in the Tisean package which can be ported to m-files easily. This is not as difficult a task as linking FORTRAN code to oct files. I have put 5 programs in this category.
Last but not least, I have 41 programs in C that need to be linked to Oct files. There are 41 programs in this category.
 
My plan is to try to work with sections of the library at the time. As described below, I intend to begin with the programs connected to Nonlinear noise reduction. The goal is to then document all those files and create a usable package. After finishing those functions I intend to move to another area of the TISEAN package and add programs that actually make a whole. As it is hard to precisely estimate how much time porting the entire TISEAN package will take, I can make small steps that will in-and-of-themselves form a whole.
 
Thus every milestone will be finishing each section of the TISEAN package.
 
I would like to tackle them in the following order:
* Nonlinear noise reduction
* Testing for nonlinearity
* Nonlinear prediction
* Lapunov Exponents
* Dimensions and entropies
 
Once those are completed I will look at other programs to be ported. The idea though, is to focus on getting a solid start for porting this library.
 
== Where I intend to start ==
 
I will start with a small step of porting all of the functions needed for [http://www.mpipks-dresden.mpg.de/~tisean/Tisean_3.0.1/index.html| Nonlinear noise reduction]. The functions I will need is: henon (for generating data), addnoise, ghkss and project. They cover all of the three categories I talked about in the first section. I have already reimplemented henon in m-file, it is accessible [http://agora.octave.org/snippet/hOzw/ here]. Both addnoise and project are in FORTRAN and need to be linked to C++ files and compiled into oct files. Lastly, ghkss is implemented in c and needs to be linked to a C++ oct file.
 
== Where I am at ==
I have already ported henon. I have also been able to link with FORTRAN programs addnoise and project. My progress can be viewed [https://bitbucket.org/josiah425/tisean| here].


My estimates might be high, but I believe it is more important to complete the task thoroughly than to port more programs haphazardly.
== Explanation of what I want to do with each file ==
Each FORTRAN file that need to be linked to an Oct file needs work done on it. I plan to take the following steps with each FORTRAN program:
# Change the FORTRAN program into a subroutine. The arguments of this subroutine will be the parameters that this program would have normally read from the user during execution.
# Move input parsing and validation from the FORTRAN files to the .cc file which will link the respective fortran file to it. This will make the fortran subroutines 'dumb' and unable to distinguish between good and bad data.
# Eliminate all file inputs and outputs. The fortran programs write and read data to/from files. This is unnecessary in Octave, as data can be supplied and retrieved to/from these subroutines directly via oct files.
# Test the oct file against the original library to ensure I didn't make mistakes.


== Details of work on each program ==
I plan to do similar steps for the c files. I believe this stage will be easier as the c code is much better organized and eliminating input validation & parsing, file inputs and outputs should be a much easier task.
* FORTRAN linking
For each FORTRAN program that I intend to link to a oct-file I intend to:
# Strip the program of its input validation and transform it into a subroutine
# Create a .cc program (compiled into an oct-file) that will launch the stripped FORTRAN subroutine; this .cc program will also not contain input validation, it will be for internal use only
# Create a m-file that will perform input validation and launch the .cc and contain usage documentation
* C linking
I intend to do here something similar to the FORTRAN programs, although, it might be better to not create any extra m-files and incorporate the program's existing input validation into the .cc file. This might be a desired course of action. I will make a decision once I complete one such linking program.
* Reimplementing in mfile
This is quite straightforward, although it is important not to make a mistake while taking this approach.
Please note that all contributions to Octave may be edited, altered, or removed by other contributors. If you do not want your writing to be edited mercilessly, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource (see Octave:Copyrights for details). Do not submit copyrighted work without permission!

To edit this page, please answer the question that appears below (more info):

Cancel Editing help (opens in new window)