Prevent Screen from Turning Off While Playing Videos on Linux

If you're using Ubuntu with Gnome/Unity and your screen turns off (screensaver) while watching videos in your browser (YouTube or others), this might solve your problem.

#!/bin/bash -eu

# List your browsers here
browsers_list=( "firefox" "chrome" "chromium" "opera" )

# Cleanup bad state left behind if user exited while flash was running
gconftool-2 -s /apps/gnome-screensaver/idle_activation_enabled \
    --type bool true

idle_off=0

while true; do

    sleep 60

    for browser in "${browsers_list[@]}" ; do
    for pid in `pgrep $browser` ; do

        flash_on=0
        if [ -O /proc/$pid/maps ] && \
            grep libflashplayer /proc/$pid/maps > /dev/null ; then
            flash_on=1
        fi

        ss_on=`gconftool-2 -g /apps/gnome-screensaver/idle_activation_enabled`

        if [ "$flash_on" = "1" ] && [ "$ss_on" = "true" ]; then
            gconftool-2 -s /apps/gnome-screensaver/idle_activation_enabled \
                --type bool false
            idle_off=1
        elif [ "$flash_on" = "0" ] && [ "$ss_on" = "false" ] \
                && [ "$idle_off" = "1" ]; then
            gconftool-2 -s /apps/gnome-screensaver/idle_activation_enabled \
                --type bool true
            idle_off=0
        fi

    done
    done

done

Save this script somewhere, chmod +x it, and add it to the Startup Applications so it runs when you log in. Don't forget to add your browsers in the first array!

Fraction patterns like 987654321 / 123456789

I came across this funny problem and I wanted to share a very nice solution to explain the behavior of such fractions in any numerical basis (the fraction in the title is in base 10, obviously :). So here it is; beginning with the following definition: \[ S_n(a) = 1 + 2a + ... + na^{n-1} = \sum_{k=1}^n k a^{k-1} = \frac{ n a^{n+1} - (n+1) a^n + 1 }{ (a-1)^2 } \] Given this, it's easy to see that \[ \frac{ [\ (b-1), (b-2), ...\ , 1\ ]_b }{ [\ 1, 2, ...\ , (b-1)\ ]_b } = \frac{ S_{b-1}(b) }{ b^{b-2} S_{b-1}(1/b) } = \frac{ 1 + (b-2)\ b^b }{ b^b - b(b-1) -1 } \] In particular, the fraction in the title equals (with $b=10$): \[ \frac{ 1 + 8.10^{10} }{ 10^{10} - 91 } \approx \frac{ 1 + 8.10^{10} }{ 10^{10} } \approx 8 \]

Siglot: a concise C++ STL implementation of Signals and Slots

I just finished a small project on Github, it's called Siglot. I started this little project to prove that Signals and Slots could be implemented easily and efficiently in C++ without calling heavy libraries like Qt, Boost or complicated headers like FastDelegates. I think I reached a satisfactory result with a clean 300-lines header (with comments), which includes only one STL header. I hope you'll find it useful!

If you try any benchmarking, I would be really interested to see the results! I'm also not sure if this is thread-safe and would be extremely grateful for any insight in this regard. In any case, send me a short message if you liked it ;)

Listing all Permutations: The Recursive Way

Here is a general algorithm for listing all permutations of an array recursively. The code is given in C++, but can easily be ported to any language:

#ifndef __PERMUTE__
#define __PERMUTE__

template <class T>
void swap( T *a, T *b )
{
    T c = *a;
    *a  = *b;
    *b  = c;
}

template <class T>
void permute( T *array, const unsigned& size, unsigned current )
{
    if ( current == size-1 )
    {
        // Do what you want with the current permutation
    }
    else
    {
        for ( unsigned i = current; i < size; ++i )
        {
            swap( array+current, array+i );
            permute( array, size, current+1 );
            swap( array+current, array+i );
        }
    }
}

#endif

Pseudo-Random Numbers Generation with C++11

A short post on how to generate random variables with the new header "random" in the STL. I provide a header file that is useful to me whenever I use this new feature; maybe you'll find it useful too. Here is a usage example (assuming you put the header in the same directory):

#include "random_engine.h"
#include <iostream>

using namespace std;

int main()
{
      std::uniform_int_distribution<unsigned> U(1, 15);
      auto generator = RandomEngine::bind_to(U);

      cout << generator() << endl;
      cout << generator() << endl;
      cout << generator() << endl;
      cout << generator() << endl; 

      cout << "------------" << endl; 

      cout << U( *RandomEngine::get() ) << endl;
      cout << U( *RandomEngine::get() ) << endl;
      cout << U( *RandomEngine::get() ) << endl;
      cout << U( *RandomEngine::get() ) << endl;
}

Rank Values in C++: Enhancing std::sort

I'm providing a header file that defines two functions for ranking values stored either in an iterable container or simply in a plain array. If you want to rank N values, make sure your "rank" array is of size N too! The trick is merely to exploit the third input of std::sort :)

Tokenize strings in C++

You might have wondered at least once how to simply tokenize a string in C++. Here is a nice and easy way to do it using string streams, inserting tokens into a vector:

#include <string>
#include <vector>
#include <sstream>
#include <iterator>
#include <algorithm>

using namespace std;

void tokenize_string( string words, vector<string>& tokens )
{
   tokens.clear();
   istringstream iss(words);
   copy( 
      istream_iterator<string>(iss), 
      istream_iterator<string>(), 
      back_inserter<vector<string> >(tokens) 
   );
}

Now, say you want to put the tokens into a set instead.. how would you do it? Here it is with a few changes:

#include <set>
#include <string>
#include <vector>
#include <sstream>
#include <iterator>
#include <algorithm>

using namespace std;

struct set_inserter : public iterator< input_iterator_tag, string >
{
   string word;
   set<string>* container;

   set_inserter( set<string>& c ): container(&c) {}
   inline reference operator* () { return word; }
   set_inserter& operator++ () { container->insert(word); return *this; }
};



void tokenize_string( string words, set<string>& tokens )
{
   tokens.clear();
   istringstream iss(words);
   copy( 
      istream_iterator<string>(iss), 
      istream_iterator<string>(), 
      set_inserter(tokens) 
   );
}

What did I do? I replaced the back inserter with my own structure, which behaves virtually as an interator, even though it's not. You can tweak this structure as you want to perform the treatment that you want, provided that you overload the indirection and the left-increment operators as I did :) That's all!