Class Function_ceil

                      object --+                        
                               |                        
structure.sage_object.SageObject --+                    
                                   |                    
           structure.element.Element --+                
                                       |                
         structure.element.ModuleElement --+            
                                           |            
               structure.element.RingElement --+        
                                               |        
                              SymbolicExpression --+    
                                                   |    
                                   PrimitiveFunction --+
                                                       |
                                                      Function_ceil

The ceiling function.

The ceiling of $x$ is computed in the following manner.
\begin{enumerate}

\item The \code{x.ceil()} method is called and returned if it is there.
     If it is not, then \sage checks if $x$ is one of Python's
     native numeric data types.  If so, then it calls
     and returns \code{Integer(int(math.ceil(x)))}.

\item \sage tries to convert $x$ into a \class{RealIntervalField} with 53
      bits of precision. Next, the ceilings of the endpoints are computed.
      If they are the same, then that value is returned.  Otherwise, the
      precision of the \class{RealIntervalField} is increased until they
      do match up or it reaches \code{maximum_bits} of precision.

\item If none of the above work, \sage returns a \class{SymbolicComposition}
     object.
     
\end{enumerate}
     
EXAMPLES:
    sage: a = ceil(2/5 + x)
    sage: a
    ceil(x + 2/5)
    sage: a(4)
    5
    sage: a(4.0)
    5
    sage: ZZ(a(3))
    4
    sage: a = ceil(x^3 + x + 5/2)
    sage: a
    ceil(x^3 + x + 1/2) + 2
    sage: a(x=2)
    13

    sage: ceil(log(8)/log(2))
    3

    sage: ceil(5.4)
    6
    sage: type(ceil(5.4))
    <type 'sage.rings.integer.Integer'>

    sage: ceil(factorial(50)/exp(1))
    11188719610782480504630258070757734324011354208865721592720336801
    sage: ceil(SR(10^50 + 10^(-50)))
    100000000000000000000000000000000000000000000000001
    sage: ceil(SR(10^50 - 10^(-50)))
    100000000000000000000000000000000000000000000000000

File: sage/structure/element.pyx (starting at line 291)

Return the ceiling of x as a float.
This is the smallest integral value >= x.