time.clock

            raise AssertionError('Found difference at %s : %s != %s' %
                                 (curpos, name(elt1), name(elt2) ), curpos)
 
from time import time, clock
def test_samples( samples ):
    time_reports = {}
    for sample in samples:
        print "testing", sample
        tstart1, cstart1 = time(), clock()
        pypy_tuples = pypy_parse(sample)
        tstart2, cstart2 = time(), clock()
        python_tuples = python_parse(sample)
        time_reports[sample] = (time() - tstart2, tstart2-tstart1, clock() - cstart2, cstart2-cstart1 )

            raise AssertionError('Found difference at %s : %s != %s' %
                                 (curpos, name(elt1), name(elt2) ), curpos)
 
from time import time, clock
def test_samples( samples ):
    time_reports = {}
    for sample in samples:
        print "testing", sample
        tstart1, cstart1 = time(), clock()
        pypy_tuples = pypy_parse(sample)
        tstart2, cstart2 = time(), clock()
        python_tuples = python_parse(sample)
        time_reports[sample] = (time() - tstart2, tstart2-tstart1, clock() - cstart2, cstart2-cstart1 )

This uses copy() instead of Vec3.clone(), and it's adapted for ShedSkin.
"""
 
from time import clock
from sys import stderr, maxint, argv
from copy import copy
from math import sqrt, pi, floor

    def main(args):
        BH.parse_cmd_line(args)
 
        if BH.print_msgs:
            print "nbody =", BH.nbody
 
        start0 = clock()
        root = Tree()
        root.create_test_data(BH.nbody)
        end0 = clock()
        if BH.print_msgs:
              print "Bodies created"
 
        start1 = clock()

            root.step_system(i)
            i += 1
            tnow += BH.DTIME
        end1 = clock()
 
        if BH.print_results:
            for j, b in enumerate(root.bodies):

from sympy import Plot
from sympy import sin, cos, pi, sqrt, exp
 
from time import sleep, clock
 
def main():
    x,y,z = symbols('xyz')

    def lambda_vs_sympy_evaluation():
        start = clock()
        p[4] = x**2+y**2, [100], [100], 'style=solid'
        p.wait_for_calculations()
        print "lambda-based calculation took %s seconds." % (clock()-start)
 
        start = clock()
        p[4] = x**2+y**2, [100], [100], 'style=solid; use_sympy_eval'
        p.wait_for_calculations()
        print "sympy substitution-based calculation took %s seconds." % (clock()-start)

from sympy import Plot
from sympy import sin, cos, pi, sqrt, exp
 
from time import sleep, clock
 
def main():
    x,y,z = symbols('xyz')

    def lambda_vs_sympy_evaluation():
        start = clock()
        p[4] = x**2+y**2, [100], [100], 'style=solid'
        p.wait_for_calculations()
        print "lambda-based calculation took %s seconds." % (clock()-start)
 
        start = clock()
        p[4] = x**2+y**2, [100], [100], 'style=solid; use_sympy_eval'
        p.wait_for_calculations()
        print "sympy substitution-based calculation took %s seconds." % (clock()-start)

from sympy import Plot
from sympy import sin, cos, pi, sqrt, exp
 
from time import sleep, clock
 
def main():
    x,y,z = symbols('xyz')

    def lambda_vs_sympy_evaluation():
        start = clock()
        p[4] = x**2+y**2, [100], [100], 'style=solid'
        p.wait_for_calculations()
        print "lambda-based calculation took %s seconds." % (clock()-start)
 
        start = clock()
        p[4] = x**2+y**2, [100], [100], 'style=solid; use_sympy_eval'
        p.wait_for_calculations()
        print "sympy substitution-based calculation took %s seconds." % (clock()-start)

# (c) Reinhold P. Weicker,  CACM Vol 27, No 10, 10/84 pg. 1013.
# --- Translated from ADA to C by Rick Richardson.
# --- Translated from C to Python by Guido van Rossum.
 
from time import clock
 
LOOPS = 50000

    global PtrGlb
    global PtrGlbNext
 
    starttime = clock()
    for i in range(loops):
        pass
    nulltime = clock() - starttime

    String1Loc = "DHRYSTONE PROGRAM, 1'ST STRING"
    Array2Glob[8][7] = 10
 
    starttime = clock()
 
    for i in range(loops):
        Proc5()

        IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1
        IntLoc1 = Proc2(IntLoc1)
 
    benchtime = clock() - starttime - nulltime
    return benchtime, (loops / benchtime)
 
def Proc1(PtrParIn):

from datetime import datetime, time
import os
import random
from time import clock, strptime
 
import wx
import wx.lib.colourdb as colourdb

    def _timeCall(self, func, msg):
        t = clock()
        simpleTiming = True
        if simpleTiming:
            func()
        else:
            self._profileCall(func, msg)
        statusMsg = msg % ((clock()-t)*1000)
        self.frame_1_statusbar.SetStatusText(statusMsg, 0)
 
    def _profileCall(self, func, msg):
        self.frame_1_statusbar.SetStatusText("Starting profile", 0)
        t = clock()

        stats = pstats.Stats("app.prof")
        stats.strip_dirs()
        stats.sort_stats('time', 'calls')
        print msg % ((clock()-t)*1000)
        stats.print_stats(30)
        os.remove("app.prof")
 

from sympy.mpmath import functions as mpf_funs
 
import math
from time import clock
import sys
 
def display_fraction(digits, skip=0, colwidth=10, columns=5):

        skip = len(intpart)
    print "Step 1 of 2: calculating binary value..."
    prec = int(n*math.log(base,2))+10
    t = clock()
    a = func(prec)
    step1_time = clock() - t
    print "Step 2 of 2: converting to specified base..."
    t = clock()
    d = libmpf.bin_to_radix(a.man, -a.exp, base, n)
    d = libmpf.numeral(d, base, n)
    step2_time = clock() - t

from sympy.mpmath import functions as mpf_funs
 
import math
from time import clock
import sys
 
def display_fraction(digits, skip=0, colwidth=10, columns=5):

        skip = len(intpart)
    print "Step 1 of 2: calculating binary value..."
    prec = int(n*math.log(base,2))+10
    t = clock()
    a = func(prec)
    step1_time = clock() - t
    print "Step 2 of 2: converting to specified base..."
    t = clock()
    d = libmpf.bin_to_radix(a.man, -a.exp, base, n)
    d = libmpf.numeral(d, base, n)
    step2_time = clock() - t