Thursday, 9 October 2014

Stopping a run-time plot via key-press using threads in pylab

You can use threads to tell a python script to end a plotting loop:
#!/usr/bin/env python
from pylab import *
import threading
import time

# Replot some data each time is called
def replot(datafile, title) :

    # Control errors (mainly "file not found")
    try :

        # read the data file 
        data=loadtxt(datafile)

        # open figure (in case create it)
        fig = figure(title)

        # clear canvas    
        fig.clear()
        # plot data
        plot(data.T)
        # redraw
        fig.canvas.draw()

    except :
        pass


# A thread dedicated to read the keyboard
class KeyPressThread(threading.Thread):
    def run(self):
        global end_thread;

        # wait for keypress
        raw_input()

        lock = threading.Lock()
        lock.acquire()

        # if a key is pressed switch 
        # the end flag to true
        end_thread = True;

        lock.release()


if __name == "__main__" :

    ion()
    close('all')

    # init the end flag
    end_thread = False

    # Start the dedicated thread
    k = KeyPressThread()
    k.start()

    # start the replot loop
    while(not end_thread) :
        replot("my_data","my_plot")

    # link the thread to main thread
    k.join()

Thursday, 2 October 2014

Reformatting latex code with Vim

Vim can be used as a very  nice latex IDE with the help of the vim-latex plugin. Unfortunatelly format indenting the selected code (SHIFT+=) does not include latex comments (using the '%' delimiter).
This issue can be solved by manually replacing the delimiter with a neutral string before formatting and then restoring the original delimiter.

The code shown below does the job. Any delimiter can be given as the argument of the IndentComments function so that  it can be used with any type of code. The last  line creates a map for calling the function set on latex by pressing '§'.

Just add it to your  ~/.vimrc configuration file.



" Solve the issue of formatting comments 
" @param delimiter  the comment delimiter for the chosen filetype"
function! IndentComments(delimiter) range

    " set a temporary substitute for the delimiter 
    let s:tmp_delimiter = 'delimiter>>>>'

    " replace the delimiter with the substitute
    exec a:firstline.','.a:lastline.' '.'s/'.a:delimiter.'/'.s:tmp_delimiter.'/'

    " reformat all lines in the range
    exec a:firstline.','.a:lastline.' '.'normal! =='

    " put back the original delimiter
    exec a:firstline.','.a:lastline.' '.'s/'.s:tmp_delimiter.'/'.a:delimiter.'/'

endfunction

" mapping '§' to reformat selected code in latex
:map <silent> § :call IndentComments("%") <CR>

Tuesday, 23 September 2014

Variadic print_log function

The c++11 standard allows the easy implementation of functions with variadic arguments. This ability can be exploited to build a user friendly log printing function that can take a variable number of arguments of different types:
    ...   
    // armadillo linear algebra library - http://goo.gl/5UmGY  
    arma::vec v = arma::randu<vec>(4);                                                                              
                                                                              
    print_log("this is the ",1,"-st example." );
    print_log("\u03C0 = ", pi, " and \u03C0/2 =",pi/2.0 );
    print_log();
    print_log("a vector: ",v.t());
    ...
Output:
this is the 1-st example.
π = 3.14159 and π/2 =1.5708

a vector:    0.8402   0.3944   0.7831   0.7984


First we provide the atomic versions of the function print_log defined respectivelly for zero and one arguments. Then we overload them with a variadic version taking a simple argument plus a variadic argument. Within the variadic print_log the one-argument print_log  is first called on the simple argument. Then the variadic print_log itself is called on the variadic argument which it will split again into a single argument plus a variadic argument. Thus all arguments will be printed one by one throught the one-argument print_log.

We also define a terminator function calling the one-argument print_log with the line-feed string as the argument. This function will be always called at the end of the recursion in the variadic print_log.  A pre-processor condition allows to choose at compile time if logs are to be printed or not. This is done by implementing an empty one-argument print_log  if the macro NOLOG is defined.
#include <iostream>

using namespace std;

#ifdef NOLOG

// empty one-argument version
template<typename T>
inline void print_log(T&& t) {  }

// empty one-argument-no-endline version
template<typename T>
inline void print_log_not_ended(T&& t ) { }

#else

// one-argument version
template<typename T>
inline void print_log(T&& t ) { cout << t << endl;  }

// one-argument-no-endline version
template<typename T>
inline void print_log_not_ended(T&& t ) { cout << t; }

#endif

// termination version
inline void print_log() {  cout << endl;  }

// variadic version
template<typename Arg, typename... Args>
inline void print_log(Arg&& arg1, Args&&... args)
{
    print_log_not_ended(arg1);
    print_log(args...);
    if( sizeof...(args) < 1  )
        print_log();
}