added example ifelse Op in cifar summer school

doc/cifarSC2011/advanced_theano.txt

@@ -207,6 +207,63 @@ Debugging
   - Run Python code (better error messages and can be debugged interactively in the Python debugger)
 
 
+Conditions
+----------
+**IfElse**
+
+- build condition over symbolic variables
+- IfElse Op takes a boolean condition and two variables to compute as input
+- while switch evaluate both 'output' variables, IfElse is lazy and only
+  evaluate one variable respect to the condition
+
+**IfElse Example: Comparison with Switch**
+
+
+.. code-block:: python
+
+  from theano import tensor as T
+  from theano.lazycond import ifelse
+  import theano, time, numpy
+
+  a,b = T.scalars('a','b')
+  x,y = T.matrices('x','y')
+  
+  z_switch = T.switch(T.lt(a,b), T.mean(x), T.mean(y))
+  z_lazy = ifelse(T.lt(a,b), T.mean(x), T.mean(y))
+
+  f_switch = theano.function([a,b,x,y], z_switch, 
+                      mode=theano.Mode(linker='vm'))
+  f_lazyifelse = theano.function([a,b,x,y], z_lazy,
+                      mode=theano.Mode(linker='vm'))
+
+  val1 = 0.
+  val2 = 1.
+  big_mat1 = numpy.ones((10000,1000))
+  big_mat2 = numpy.ones((10000,1000))
+
+  n_times = 10
+
+  tic = time.clock()
+  for i in xrange(n_times):
+      print f_switch(val1, val2, big_mat1, big_mat2)
+  print 'time spent evaluating both values %f sec'%(time.clock()-tic)
+
+  tic = time.clock()
+  for i in xrange(n_times):
+      print f_lazyifelse(val1, val2, big_mat1, big_mat2)
+  print 'time spent evaluating one value %f sec'%(time.clock()-tic)
+
+IfElse Op spend less time (about an half) than Switch since it computes only
+one variable instead of both.
+
+
+>>> python ifelse_switch.py
+time spent evaluating both values 0.6700 sec
+time spent evaluating one value 0.3500 sec
+
+Note that IfElse condition is a boolean while Switch condition is a tensor, so
+the comparison might be unfair.
+
 Loops
 -----
 

theano/gof/tests/test_lazy.py

@@ -84,11 +84,6 @@ class IfElseIfElseIf(PureOp):
 class NotImplementedOp(PureOp):
     class E(Exception): pass
 
-    def __eq__(self, other):
-        return type(self) == type(other)
-    def __hash__(self):
-        return hash(type(self))
-
     def make_node(self, x):
         return Apply(self, [x], [x.type()])
     def make_thunk(self, node, storage_map, compute_map, no_recycling):