Merge lp:~toineo/unity-lens-applications/calculator into lp:unity-lens-applications

[toineo]

This mainly adds a calculator to the <alt-f2> mode.
The refactored runner should also permit easier integration of other modes, in the future.

To try it : <alt-f2> + "= yourexpression", e.g "= 2 * tan(7) / 5"

It implements bug #778036.

I would like to thank Didrocks for his very useful help in making this little contribution, and for the time he spent answering my questions.

[Didier Roche-Tolomelli (didrocks)]

excellent work, sponsoring, thanks!

review: Approve

[Didier Roche-Tolomelli (didrocks)]

opss, wrong window, sorry, was looking at another merge, will look at the one later ;)

[Didier Roche-Tolomelli (didrocks)]

review: Needs Fixing

[Didier Roche-Tolomelli (didrocks)]

Hey toineo,

Thanks for this awesome work!
so some comments on the proposed branch:

+ if ((result = process_easter (ref search_string, ref model)) != 0)
I would just make process_easter returns true or false and don't care about the result (we don't really need to differentiate them)

----------------

549 + string uri;
550 + Icon icon;
551 + uri = "unity-calc";
552 + string result_string = _(format_result_output (search_string, result));
-> can you pease fix the ident?

575 + string uri;
576 + Icon icon;
577 + uri = "unity-calc";
578 + string result_string = _(format_result_output (search_string, result));
-> same remark

Btw, you have this code twice, can you try a while loop with an arg being true as long as the result is invalid and we can still tweak the search by adding ')' and such?

----------------------

63 + private Gee.HashMap<string,DelegateWrapper1> TwoLettersFct;
64 + private Gee.HashMap<string,DelegateWrapper1> ThreeLettersFct;
65 + private Gee.HashMap<string,DelegateWrapper1> FourLettersFct;
66 + private Gee.HashMap<string,DelegateWrapper1> FiveLettersFct;

As we discussed, I would prefer an double HashMap with 2,3,4,5 has a primary index to select the right subhashmap reference

------------------------
256 + /* FIXME : at this time, something like tan7 is evaluated
257 + * as tan(7). Do we accept this behavior ? */

-> it's fine for now ;)

Awesome work! can you please look at those remarks and see how to fix them? The rest looks good :-)

Thanks again for working on that!

[toineo (toineo)]

Didrocks, fix commited for this. Thank you for reviewing, and for your help !

[toineo (toineo)]

History should now show with an empty search, as in the trunk version.

[toineo (toineo)]

The merge request is frozen for now. I have fixed the bug of bad double printing (e.g something like 2.1 that was printed as 2.0999999999998) -- and I should push those changes --, but we still have difficulties to know if the computation was exact or not (and that will be clearly visible to the user, through the equal sign (= or ≈, depending on the case)).

I see 3 way to fix it :
- Add some code to the equation parser that detects approximations. This should work for many simple (or not so simple) cases, but would probably still fail on more difficult ones.
- Use an external binding for a bignum (including bigfloat) library. With a good library, we should make almost no error telling if the computation was exact or not. Unfortunately, I found no such binding for vala...
- Write an implementation of bignums directly in the parser. But it would take some time, in particular for some operations/functions. Moreover, it would be like reinventing the wheel...

If anyone had a solution or something that could help, it would be greatly appreciated !

(Sorry for my *bad* English...)

review: Needs Fixing

[Mikkel Kamstrup Erlandsen (kamstrup)]

The simpler solution the better I'd say. Pulling in some numeric lib
just to support this seems way out of proportion; writing custom
arbitrary precision math routines or advanced parsers is way out of
scope for something that's definitely never intended as a full fledged
calculator.

If we can just always get a sensible result I think it is good enough
- no need to differentiate = or ≈. If people care about high precision
math I don't think the dash is the place to look for it. - or it would
have to go in a dedicated math lens at the very least (woohoo, i see
symbolic equation solvers coming in ;-))

[toineo (toineo)]

Thank you for your answer Mikkel !

Well, last time I discussed with Didier, he told me he really prefers a calculator with an accurate differentiation of = and ≈, and that an user who asks to compute something like 10^18 + 2 (but less obvious, of course) will be unhappy with a result of 1×10¹⁸ and nothing indicating it is an approximation. I agree with it -- even if, you are completely right, it is not intended to be a precision calculator. It is just that it is a pity not to be able to warn the user ; but I agree, the means have to be commensurate with the goals.

For a version with no equal/approximate sign (or with the same sign whatever the computation), the last revision of this branch should be almost ready for review (it only needs a fix for the bug of broken function calls), I have not currently found other bugs.

I find the idea of a math lens great ! It would be a killer feature ! It could completely go along with the alt-f2 calculator (which is only for some quick results, and could possibly have a link to the math lens). I want it :D

(Same thing, sorry for my english...)

[toineo (toineo)]

Now, the branch should be up-to-date with trunk.

(I switch to abstain because I cannot switch to "needs reviews")

review: Abstain

Unmerged revisions

219. By toineo on 2011-08-12

Remerged against njpatel's and didrocks' work

218. By toineo on 2011-08-09

Fix the bug of broken function calls.
Fix a bug due to the "useless + deleting" (now, (+-+-7) is correctly evaluated).
Add log10 to the function set.

217. By toineo on 2011-08-06

Fixing the approximations due to the double type.
Removing the display of the search string, before the result.

216. By toineo on 2011-08-04

Improving results display.

215. By toineo on 2011-08-03

Fixing regression of history not displayed on empty search.
Removing useless comments and fixing indentation.

214. By toineo on 2011-08-03

Implementing double hashmap for size-based function processing.
Fixing minor issues (bool process_easter(), indent problem, shameful process_computation() structure).

213. By toineo on 2011-08-03

Refactored runner with mode support
Adding equation parser and corresponding calculator mode in runner

=== modified file 'src/Makefile.am'
--- src/Makefile.am	2011-08-04 07:27:33 +0000
+++ src/Makefile.am	2011-08-12 07:58:24 +0000
@@ -52,6 +52,7 @@
   runner.vala \
   schemas.vala \
   utils.vala \
+  equationparser.vala \
   $(NULL)
 
 unity-package-search.o : $(srcdir)/unity-package-search.cc $(srcdir)/unity-package-search.h

=== added file 'src/equationparser.vala'
--- src/equationparser.vala	1970-01-01 00:00:00 +0000
+++ src/equationparser.vala	2011-08-12 07:58:24 +0000
@@ -0,0 +1,416 @@
+/*
+ * Copyright (C) 2011 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by Antoine Voizard
+ *
+ */
+
+
+using Gee;
+
+namespace Unity.ApplicationsLens
+{
+  private delegate double Delegate1(double a);
+  private delegate double Delegate2(double a, double b); // Math operators
+  
+  private class DelegateWrapper1 
+  {
+    public Delegate1 d;
+    public DelegateWrapper1(Delegate1 d) 
+    {
+        this.d = d;
+    }
+  }
+  private class DelegateWrapper2
+  {
+    public Delegate2 d;
+    public DelegateWrapper2(Delegate2 d) 
+    {
+        this.d = d;
+    }
+  }
+  
+  private class EquationParser
+  {
+    private Gee.HashMap<int,Gee.HashMap<string,DelegateWrapper1>> Functions;
+    private const int MAXFCTSIZE = 5; 
+    private const int MINFCTSIZE = 2;
+    
+    private Gee.HashMap<string,DelegateWrapper2> Operators;
+    private ArrayList<string> [] PrioritizedOperators;// = {{"^"}, {"*", "/"}, {"+", "-"}};
+    
+    private char [] signs = {'+', '-'};
+    
+    public int MaxPrec {get; private set;}
+    
+    public EquationParser ()
+    {
+      Functions = new Gee.HashMap<int,Gee.HashMap<string,DelegateWrapper1>> ();
+      for (int i = MINFCTSIZE; i <= MAXFCTSIZE; i++)
+        Functions[i] = new Gee.HashMap<string,DelegateWrapper1> ();
+      
+      Operators = new Gee.HashMap<string,DelegateWrapper2> ();
+      
+      PrioritizedOperators = {new ArrayList<string> (),
+      new ArrayList<string> (),
+      new ArrayList<string> ()};
+      
+      Functions[2]["ln"] = new DelegateWrapper1 (Math.log);
+      Functions[2]["th"] = new DelegateWrapper1 (Math.tanh);
+      Functions[2]["sh"] = new DelegateWrapper1 (Math.sinh);
+      Functions[2]["ch"] = new DelegateWrapper1 (Math.cosh);
+      Functions[2]["j0"] = new DelegateWrapper1 (Math.j0); // Bessel function, just in case
+      Functions[2]["j1"] = new DelegateWrapper1 (Math.j1);
+      Functions[2]["y0"] = new DelegateWrapper1 (Math.y0);
+      Functions[2]["y1"] = new DelegateWrapper1 (Math.y1);
+      
+      Functions[3]["sin"] = new DelegateWrapper1 (Math.sin);
+      Functions[3]["cos"] = new DelegateWrapper1 (Math.cos);
+      Functions[3]["tan"] = new DelegateWrapper1 (Math.tan);
+      Functions[3]["exp"] = new DelegateWrapper1 (Math.exp);
+      Functions[3]["abs"] = new DelegateWrapper1 (Math.fabs);
+      Functions[3]["log"] = new DelegateWrapper1 (Math.log);
+      Functions[3]["erf"] = new DelegateWrapper1 (Math.erf);
+      
+      Functions[4]["asin"] = new DelegateWrapper1 (Math.asin);
+      Functions[4]["acos"] = new DelegateWrapper1 (Math.acos);
+      Functions[4]["atan"] = new DelegateWrapper1 (Math.atan);
+      Functions[4]["sinh"] = new DelegateWrapper1 (Math.sinh);
+      Functions[4]["tanh"] = new DelegateWrapper1 (Math.tanh);
+      Functions[4]["cosh"] = new DelegateWrapper1 (Math.cosh);
+      Functions[4]["ceil"] = new DelegateWrapper1 (Math.ceil);
+      Functions[4]["log2"] = new DelegateWrapper1 ((a) => {return Math.log (a) / Math.LN2;});
+      
+      Functions[5]["trunc"] = new DelegateWrapper1 (Math.trunc);
+      Functions[5]["round"] = new DelegateWrapper1 (Math.round);
+      Functions[5]["floor"] = new DelegateWrapper1 (Math.floor);
+      Functions[5]["asinh"] = new DelegateWrapper1 (Math.asinh);
+      Functions[5]["acosh"] = new DelegateWrapper1 (Math.acosh);
+      Functions[5]["atanh"] = new DelegateWrapper1 (Math.atanh);
+      Functions[5]["log10"] = new DelegateWrapper1 (Math.log10);
+            
+      // TODO :  cotan, etc ?
+      
+      Operators["+"] = new DelegateWrapper2 ((a, b) => {return a + b;});
+      Operators["-"] = new DelegateWrapper2 ((a, b) => {return a - b;});
+      Operators["*"] = new DelegateWrapper2 ((a, b) => {return a * b;});
+      Operators["/"] = new DelegateWrapper2 ((a, b) => {return a / b;});
+      Operators["^"] = new DelegateWrapper2 (Math.pow);
+      
+      /* Cheap way to force priority between operators, and to process 
+       * equal-priority operators together */
+      PrioritizedOperators[0].add ("^");
+      PrioritizedOperators[1].add ("*");
+      PrioritizedOperators[1].add ("/");
+      PrioritizedOperators[2].add ("+");
+      PrioritizedOperators[2].add ("-");
+      
+      MaxPrec = int.parse (double.EPSILON.to_string().split("e")[1].replace("-", ""));
+      
+    }
+    
+    private bool find_previous_block (string eq, int position, out int result)
+    {
+      int current = position;
+      int level = 0;
+      
+      if (position == 0) return false;
+      
+      // Spot eventual parentheses that delimit current block
+      while (current != 0)
+      {
+        current--;
+        if (eq[current] == ')')
+          level++;
+        else if (eq[current] == '(')
+        {
+          level--;
+          if (level == 0) break;
+          else if (level == -1)
+          {
+            current++;
+            level = 0;
+            break;
+          }
+        }
+        else if ((eq[current].to_string () in Operators.keys
+                  || eq[current] == ',')
+                 && level == 0)
+        {
+          current++;
+          break;
+        }
+      }
+      
+      if (level != 0) return false; // Parentheses don't match
+      
+      // FIXME : if we write, for example, tanexp(x), it will compute tan(exp(x)). Is it ok ?
+      /* We got the block, now let's check if it is 
+       * headed by a function ; if yes, include that 
+       * function in the block */
+      for (int size = MAXFCTSIZE; size >= MINFCTSIZE; size--)
+        if (current >= size && eq[current - size : current] in Functions[size].keys)
+          current -= size;
+      
+      // Heading minus sign ?
+      if (current > 0 && eq[current - 1] == '~')
+        current--;      
+      
+      result = current;
+      return true;
+    }
+    
+    private bool find_next_block (string eq, int position, out int result)
+    {
+      int current = position + 1;
+      int level = 0;
+      
+      if (current >= eq.length) return false;
+      
+      while (current < eq.length)
+      {
+        if (eq[current] == '(')
+          level++;
+        else if (eq[current] == ')')
+        {
+          level--;
+          if (level == 0) break;
+          else if (level == -1)
+          {
+            current--;
+            level = 0;
+            break;
+          }
+        }
+        else if ((eq[current].to_string () in Operators.keys
+                  || eq[current] == ',')
+                 && level == 0)
+        {
+          current--;
+          break;
+        }
+        
+        current++;
+        if (current == eq.length)
+        {
+          current--;
+          break;
+        }
+      }
+      
+      if (level != 0 || current == position) return false;
+      
+      result = current;
+      return true;
+    }
+    
+    private bool eval_block (string _block, out double result)
+    {
+      var block = _block; // FIXME : useless copy ? (ownership problem...)
+      bool inverse_sign = false;
+      
+      /* Hack that prevents problems with useless parentheses,
+       * and treats the sign inverter (~). Both cases need to 
+       * be treated together ; can be done with recursive call, btw */
+      while ((block.has_prefix ("(") && block.has_suffix (")"))
+            ||block[0] == '~')
+        if (block[0] == '~') 
+        {
+          inverse_sign = !inverse_sign;
+          block = block [1:block.length];
+        }
+        else
+          block = block[1 : -1];
+
+      // Determines if we got a function in the front of the block
+      /* FIXME : at this time, something like tan7 is evaluated
+       * as tan(7). Do we accept this behavior ? */
+      while (true)
+      {
+        bool fct_found = false;
+        for (int size = MAXFCTSIZE; size >= MINFCTSIZE; size--)
+          if (block.length > size && block[0 : size] in Functions[size].keys)
+          {
+            double sub_result;
+            if (!eval_block (block[size : block.length], out sub_result))
+              return false;
+        
+            result = Functions[size][block[0 : size]].d (sub_result);
+        
+            fct_found = true;
+            break;
+          }
+        if (fct_found) break; // We can't break the while loop inside the for one
+        
+      
+        // Now search for operators
+        if (block[0].to_string() in Operators.keys)
+        {
+          int position1, position2; // Position of term 1 and 2
+          double sub_result1 = 0, sub_result2 = 0;
+        
+          // Get first term
+          if (!(find_next_block (block, 1, out position1) 
+                && eval_block (block[2 : position1 + 1], out sub_result1)))
+            return false;
+        
+          // Second term
+          if (!(find_next_block (block, position1 + 1, out position2) 
+                && eval_block (block[position1 + 2 : position2 + 1], out sub_result2)))
+            return false;
+        
+          result = Operators[block[0].to_string()].d (sub_result1, sub_result2);
+          break;
+        }
+        
+        // Is the block a number ?
+        if (block[0].isdigit ())
+        {
+          result = double.parse (block);
+          break;
+        }
+      
+        // Constants (inelegant way...)
+        if (block == "e")
+        {
+          result = Math.E;
+          break;
+        }
+        if (block == "pi")
+        {
+          result = Math.PI;
+          break;
+        }
+      
+        return false;
+      }
+      
+      if (inverse_sign) result = 0 - result;
+      
+      return true;
+    }
+    
+    public bool compute (string equation, out double result)
+    {
+      var eq = equation.down ().replace (",", ".").replace("~", "");
+      bool no_error = true;
+      
+      // TODO : test equation's correctness
+      if (eq.length == 0)
+        return false;
+      
+      if (eq.has_prefix ("+") || eq.has_prefix ("-"))
+        eq = "0" + eq;
+      
+
+      for (int i = 0, size; i + 1 < eq.length; i++)
+      {
+        // Merge consecutive plus and minus sign
+        if (eq[i] in signs && eq[i+1] in signs)
+        {
+          if (eq[i] == eq[i+1])
+            eq = eq[0:i] + "+" + eq[i+2:eq.length];
+          else
+            eq = eq[0:i] + "-" + eq[i+2:eq.length];
+          
+          i--;
+          continue;
+        }
+        
+        // Protect function calls
+        // FIXME : this is heavy, but I have currently no other idea
+        // for this test...
+        if (eq[i].isalpha())
+          for (size = MAXFCTSIZE; size >= MINFCTSIZE; size--)
+            if (i <= eq.length - size && eq[i : i + size] in Functions[size].keys)
+            {
+              i += size;
+              eq = eq[0 : i] + "#" + eq[i : eq.length];
+              break;
+            }
+         
+        // Add implicit "*" operator
+        if ((eq[i].isdigit () && eq[i + 1].isalpha ())
+          ||(eq[i].isdigit () && eq[i + 1] == '(')
+          ||(eq[i].isalpha () && eq[i + 1] == '(')
+          ||(eq[i] == ')'     && eq[i + 1] == '(')
+          ||(eq[i] == ')'     && eq[i + 1].isalpha ()))
+            eq = eq[0 : i + 1] + "*" + eq[i + 1 : eq.length];
+        
+        // Delete unneeded plus sign
+        if (i > 0
+            && (eq[i-1].to_string () in Operators.keys || eq[i-1] == '(')
+            && eq[i] == '+')
+        {
+          eq = eq[0:i] + eq[i+1:eq.length];
+          i--;
+          //continue; // Uncomment if new tests are made in the loop, after this one
+        }
+        
+      }
+      
+      eq = eq.replace("#", "");
+      
+      /* Replace minus sign by ~ (easier to treat)
+       * This loop *has* to be separated from the previous,
+       * elsewhere it will interfer with the +/- merging */
+      for (int i = 0; i + 1 < eq.length; i++)
+        if ((eq[i].to_string () in Operators.keys || eq[i] == '(')
+            && eq[i+1] == '-')
+          eq = eq[0:i+1] + "~" + eq[i+2:eq.length];
+            
+      
+      /* Search for operators in equation
+       * The while loop does the search itself, and
+       * the for loop ensures respect of operators priority */
+      for (int op_level = 0, i; op_level < PrioritizedOperators.length && no_error; op_level++)
+      {
+        i = 0;
+        while (i < eq.length)
+        {
+          if (eq[i].to_string () in PrioritizedOperators[op_level])
+          {
+            int position1 = 0, position2 = 0;
+            // Find operands' position
+            if (!find_previous_block (eq, i, out position1)
+              ||!find_next_block (eq, i, out position2))
+            {
+              debug ("Calculator : Incorrect equation");
+              no_error = false;
+              return false;
+            }
+            // Reorganize operator and operands into polish notation
+            // FIXME : avoid multiple useless parentheses
+            eq = eq[0 : position1] + "(" + eq[i].to_string () + "," + eq[position1 : i]
+                 + "," + eq[i + 1 : position2 + 1] + ")" + eq[position2 + 1 : eq.length];
+            i += 3; 
+          }
+          else i++;
+        }
+      }
+      
+      // Computation
+      if (!eval_block (eq, out result))
+      {
+        debug ("Calculator : Unable to compute");
+        return false;
+      }
+      
+      return true;
+    }
+    
+  } // equationparser
+  
+}

=== modified file 'src/runner.vala'
--- src/runner.vala	2011-08-11 16:18:36 +0000
+++ src/runner.vala	2011-08-12 07:58:24 +0000
@@ -61,6 +61,8 @@
 
     private Settings gp_settings;
     
+    private EquationParser parser;
+    
     public Runner (Unity.ApplicationsLens.Daemon daemon)
     {
       /* First create scope */
@@ -129,6 +131,8 @@
       history = new Gee.ArrayList<string> ();
       load_history ();
       
+      parser = new EquationParser ();
+      
       this.daemon = daemon;
     
     }
@@ -152,28 +156,11 @@
     private async void update_search (LensSearch? search)
     {
       var model = scope.results_model;
-      var executables_match = new Gee.ArrayList<string> ();
-      var dirs_match = new Gee.ArrayList<string> ();
       model.clear ();
 
       var search_string = search.search_string;
       bool has_search = !Utils.search_is_invalid (search);
-
-      string uri;      
-      Icon icon;
-      string mimetype;
-      string display_name;
-      var category_id = RunnerCategory.HISTORY;
-
-      foreach (var command in this.history)
-      {          
-        display_name = get_icon_uri_and_mimetype (command, out icon, out uri, out mimetype);   
-        model.append (uri, icon.to_string (),
-                      category_id, mimetype,
-                      display_name,
-                      null);
-      }
-              
+      
       /* Prevent concurrent searches and concurrent updates of our models,
        * by preventing any notify signals from propagating to us.
        * Important: Remember to thaw the notifys with release_scopelock()! */
@@ -181,41 +168,133 @@
 
       if (!has_search)
       {
+        display_history (ref model);
         release_scopelock ();
         search.finished ();
         return;
       }
 
       Timer timer = new Timer ();
+      double result;
       
       /* no easter egg in unity */
-      if (search_string == "free the fish")
-      {
-        uri = "no-easter-egg";
-        string commenteaster = _("There is no easter egg in Unity");
-        icon = new ThemedIcon ("gnome-panel-fish");
-        model.append (uri, icon.to_string (),
-                      0, "no-mime",
-                      commenteaster,
-                      null);
-        release_scopelock ();
-        search.finished ();
-        return;
-      }
-      else if (search_string == "gegls from outer space")
-      {
-        uri = "really-no-easter-egg";
-        string commentnoeaster = _("Still no easter egg in Unity");
-        icon = new ThemedIcon ("gnome-panel-fish");
-        model.append (uri, icon.to_string (),
-                      0, "no-mime",
-                      commentnoeaster,
-                      null);
-        release_scopelock ();
-        search.finished ();
-        return;
-         
-      }
+      if (process_easter (ref search_string, ref model))
+      {
+        timer.stop ();
+        debug ("Easter egg found in %fms", timer.elapsed ()*1000);      
+      }      
+
+      /* Calculator mode (e.g "= 2 + 1") */
+      else if (process_computation (ref search_string, ref model, out result))
+      {
+        timer.stop ();
+        debug ("Equation processed in %fms", timer.elapsed ()*1000);
+      }
+      
+      /* Command mode */
+      else 
+      {
+        var executables_match = new Gee.ArrayList<string> ();
+        var dirs_match = new Gee.ArrayList<string> ();
+      
+        process_command (ref search_string, ref model, ref dirs_match, ref executables_match);
+      
+        timer.stop ();
+        debug ("Entry search listed %i dir matches and %i exec matches in %fms for search: %s",
+               dirs_match.size, executables_match.size, timer.elapsed ()*1000, search_string);      
+      }
+      
+      release_scopelock ();
+      search.finished ();
+    }
+    
+    private bool process_computation (ref string search_string, ref Dee.SharedModel model, out double result)
+    {
+      if (search_string.has_prefix ("="))
+      {
+        string uri = "unity-calc://calc";
+        Icon icon = new ThemedIcon ("accessories-calculator");
+        string result_string = "";
+        
+        if (search_string.length > 1)
+        {
+          search_string = search_string[1:search_string.length].replace (" ", "");
+          
+          // Try to complete expression by adding some closing parentheses
+          int NbOpenPar = search_string.length - search_string.replace ("(", "").length;
+          int NbClosePar = search_string.length - search_string.replace (")", "").length;
+            
+          while (NbOpenPar > NbClosePar)
+          {
+            search_string += ")";
+            NbClosePar++;
+          }
+          if (parser.compute (search_string, out result))
+          {
+            debug ("Computation : equation = " + search_string
+                  + ", result = " + result.to_string());
+  
+            result_string = _(format_result_output (search_string, result));
+          }
+          // We are definitely unable to compute that expression
+          else
+          {
+            result_string = _("Unable to compute");
+            debug ("Unable to calculate that expression : " + search_string);
+          }
+        } 
+        else // Empty string case
+        {
+          result_string = _("calc mode");
+          debug ("Empty expression");
+        }
+        
+        model.append (uri, icon.to_string (),
+                      0, "no-mime",
+                      result_string,
+                      null);
+        
+        return true;
+      }
+      
+      else return false;
+    }
+    
+    private string format_result_output (string _search_string, double result)
+    {
+      //string search_string;
+      string equal_sign = " = "; // Don't forget to put spaces around it !
+      
+      // Processing search_string (too long string will be shorted)
+      /* FIXME : Choose if we want to display, or not, the search string
+       * It is currently deactivated, to give a try *
+      if (_search_string.length > 16)
+        search_string = _search_string[0:5] + " … " +
+                        _search_string[_search_string.length-5:_search_string.length];
+      else search_string = _search_string;  */ 
+      
+      // Processing result
+      if (result == double.INFINITY) return /*search_string + " = */ "+∞";
+      else if (result == -double.INFINITY) return /*search_string + " = */ "-∞";
+      else if (result.is_nan ()) return "Unable to compute";      
+      else
+      {
+        bool approx;
+        string formated_result = Utils.format_number (result, parser.MaxPrec, 21, out approx);
+        if (approx) equal_sign = " ≈ ";
+        return /*search_string + equal_sign +*/ formated_result;
+      }
+    }
+    
+    private void process_command (ref string search_string, ref Dee.SharedModel model, ref Gee.ArrayList<string> dirs_match, ref Gee.ArrayList<string> executables_match)
+    {
+      string uri;
+      Icon icon;
+      string mimetype;
+      string display_name;
+      var category_id = RunnerCategory.HISTORY;
+      
+      display_history (ref model);
       
       /* manual seek with directory and executables result */
       if (search_string.has_prefix ("/") || search_string.has_prefix ("~"))
@@ -319,14 +398,52 @@
                       display_name,
                       null);
       }
-      
-      timer.stop ();
-      debug ("Entry search listed %i dir matches and %i exec matches in %fms for search: %s",
-             dirs_match.size, executables_match.size, timer.elapsed ()*1000, search_string);
-      
-
-      release_scopelock ();
-      search.finished ();
+    }
+    
+    private bool process_easter (ref string search_string, ref Dee.SharedModel model)
+    {
+      /* no easter egg in unity */
+      if (search_string == "free the fish")
+      {
+        string uri = "no-easter-egg";
+        string commenteaster = _("There is no easter egg in Unity");
+        Icon icon = new ThemedIcon ("gnome-panel-fish");
+        model.append (uri, icon.to_string (),
+                      0, "no-mime",
+                      commenteaster,
+                      null);
+      }
+      else if (search_string == "gegls from outer space")
+      {
+        string uri = "really-no-easter-egg";
+        string commentnoeaster = _("Still no easter egg in Unity");
+        Icon icon = new ThemedIcon ("gnome-panel-fish");
+        model.append (uri, icon.to_string (),
+                      0, "no-mime",
+                      commentnoeaster,
+                      null);
+      }
+      else return false;
+      
+      return true;
+    }
+    
+    private void display_history (ref Dee.SharedModel model)
+    {
+      string uri;
+      Icon icon;
+      string mimetype;
+      string display_name;
+      var category_id = RunnerCategory.HISTORY;
+      
+      foreach (var command in this.history)
+      {          
+        display_name = get_icon_uri_and_mimetype (command, out icon, out uri, out mimetype);   
+        model.append (uri, icon.to_string (),
+                      category_id, mimetype,
+                      display_name,
+                      null);
+      }
     }
     
     private void release_scopelock ()

=== modified file 'src/utils.vala'
--- src/utils.vala	2011-07-18 22:29:11 +0000
+++ src/utils.vala	2011-08-12 07:58:24 +0000
@@ -22,6 +22,8 @@
  
 namespace Unity.ApplicationsLens.Utils
 { 
+  private const string[] exponents = {"⁰", "¹", "²", "³", "⁴",
+                                      "⁵", "⁶", "⁷", "⁸", "⁹"};
   
   public AppInfo? get_app_info_for_actor (string actor)
   {
@@ -161,5 +163,155 @@
     else
       return pw.pw_dir + s.substring (k, -1);
   }
-
+  
+  public string to_exponent (string power)
+  {
+    string result = "";
+    string pow = power;
+    
+    if (pow[0] == '-')
+    {
+      result += "⁻";    
+      pow = pow [1:pow.length];
+    }
+    
+    // FIXME : a for loop would probably be faster, with no modifications on pow
+    while (pow.length != 0)
+    {
+      result += exponents[int.parse(pow[0:1])];
+      pow = pow[1:pow.length];
+    }
+    
+    return result;
+  }
+  
+  // Corrects precision error (due to the double type)
+  /* Those function are not particularly elegant, and they
+   * induce errors about approximations (we can display an approximate
+   * equal sign for an exact equality, and vice versa).
+   * It is related to the type we use for number representation (double), and
+   * to the fact that this calculator is not intended to be a scientific calculator.
+   * Anyway, if a bignum lib binding was available, it would be great to port this calculator
+   * to this library. */
+  public string format_number (double _num, int maxprec, int maxdisplayprec, out bool approx)
+  {
+    string num = _num.to_string();
+    
+    if (num.to_string().contains("e"))
+    {
+      string factor = _num.to_string().split("e")[0];
+      int power = int.parse(_num.to_string().split("e")[1]);
+    
+      return format_sci_number_s (ref factor, power, maxprec, maxdisplayprec, out approx);
+    }
+    else
+      return format_number_s (ref num, maxprec, maxdisplayprec, out approx);
+  }
+  
+  public string format_sci_number_s (ref string factor, int power, int maxprec, int maxdisplayprec, out bool approx)
+  {
+    string end_string = "×10" + to_exponent (power.to_string());
+    
+    string ffactor = format_number_s(ref factor, maxprec, maxdisplayprec - end_string.length, out approx);
+    
+    // FIXME : if power is one digit-longer, this can fail (there's less space for ffactor)
+    if (ffactor.length > 1 && ffactor[1] != '.')
+    {
+      ffactor = ffactor[0].to_string() + "." + ffactor[1:ffactor.length].replace(".", "");
+      remove_trailing_0 (ref ffactor);
+      power++;
+    }
+    return ffactor + "×10" + to_exponent (power.to_string());
+  }
+  
+  public string format_number_s (ref string num, int maxprec, int maxdisplayprec, out bool approx)
+  {
+    bool isint = !num.contains(".");
+    
+    if (isint) maxprec--;
+    
+    // Too long integer, we have to transform it into scientific notation
+    if (isint && (num.length > maxprec || num.length > maxdisplayprec))
+    {
+      int power = num.length - 1;
+      num = num[0].to_string() + "." + num[1 : maxprec + 1];
+      approx = true;
+      return format_sci_number_s (ref num, power, maxprec, maxdisplayprec, out approx);
+    }
+    
+    if (num.length > maxprec + 1)
+    {
+      num = num[0 : maxprec + 1];
+      approx = true;
+    }
+    
+    round (ref num, maxprec);
+    
+    if (num.length > maxdisplayprec)
+    {
+      approx = true;
+      round (ref num, maxdisplayprec);
+    }
+    
+    return num;
+  }
+  
+  public void round (ref string number, int size)
+  {
+    if (number.length <= size) return;
+    
+    string last_char = number[size].to_string();
+    
+    number = number[0 : size];
+    
+    if (int.parse(last_char) >= 5)
+      add_1_remove_trailing_9 (ref number);
+    else
+      remove_trailing_0 (ref number);
+  }
+  
+  public void remove_trailing_0 (ref string number)
+  {
+    for (int i = number.length - 1; i > 0; i--)
+    {
+      if (number[i].isdigit() && number[i] != '0')
+        break;
+      if (number[i] == '.')
+      {
+        number = number[0:number.length - 1];
+        break;
+      }
+    
+      number = number[0:number.length - 1];
+    }
+  }
+  
+  // Remove any trailing '9' (or replace it by zero, in the integer part)
+  // and increment last non-9 char
+  public void add_1_remove_trailing_9 (ref string number)
+  {
+    int i;
+    int int_part_begin = -1;
+    
+    for (i = number.length - 1; i >= 0; i--)
+    {
+      if (number[i] == '.')
+      {
+        int_part_begin = i - 1;
+        continue;
+      }
+      
+      if (number[i].isdigit() && number[i] != '9')
+        break;
+    }
+      
+    if (int_part_begin != -1)
+    {
+      if (i == -1) number = "1" + string.nfill (int_part_begin + 1, '0');
+      else number = number[0 : i] + (int.parse(number[i].to_string()) + 1).to_string() 
+                 + string.nfill (int_part_begin - i, '0');
+    }
+    else
+      number = number[0:i] + (int.parse(number[i].to_string()) + 1).to_string();
+  }
 }