len

def local_none(vec):
    return(ones(len(vec)))
 
def local_hanning(vec):
    return(hanning(len(vec)))
 
def local_hamming(vec):
    return(hamming(len(vec)))
 
def local_blackman(vec):
    return(blackman(len(vec)))
 
def local_bartlett(vec):
    return(bartlett(len(vec)))

def local_kaiser3(vec):
    return(kaiser(len(vec),3*pi))
 
 
def local_wider(vec):
    """ Flat top in middle, cos at edges - meant to be narrower in f
    but not as good in the wings
    """
    N=len(vec)

def local_flat_top_freq(vec):
    N=len(vec)
    k=arange(N)
    w = (1 - 1.93*cos(2*pi*k/(N-1)) + 1.29*cos(4*pi*k/(N-1)) 
         -0.388*cos(6*pi*k/(N-1)) +0.032*cos(8*pi*k/(N-1)))
    return(w)
 

def call_spec():
    global y,NFFT,Fsamp,Fcentre,foverlap,detrend,_window, _type, fmod, chan_name
    print len(y), NFFT,foverlap, _type, fmod
    ax = pl.subplot(111)
    z=_window(y)
    if _type=='F': 
        shot=callback.get_shot()

            select_list=get_local_shot_numbers(
                partial_name=string.strip(partial_name,'*')) # get a new list
 
        if len(select_list)==0: select_list= ['none?']  # put 'none there if it failed
        else: 
            for s in select_list: select_box.insert(Tix.END, s) # put in widget list if OK
        select_box.set_silent(select_list[0])        # and put the top entry in the window

    if axisbg==None: axisbg='lightgoldenrodyellow'
 
    global button_layout_cursor
    if xw==0: xw=0.015*(len(text)+1)
    if yh==0: yh=0.05
##    thisax=fig.add_axes([xl, yb, xw, yh], axisbg=axisbg) fundamentally wrong
    thisax=pl.axes([xl, yb, xw, yh], axisbg=axisbg)

# build the time, input, output and response arrays
dt = 0.01
t = np.arange(0.0, 20.0, dt)        # the time vector from 0..20
Nt = len(t)
 
def impulse_response(t):
    'double exponential response function'

# compute y by applying F^-1[F(x) * F(r)].  The fft assumes the signal
# is periodic, so to avoid edge artificats, pad the fft with zeros up
# to the length of r + x do avoid circular convolution artifacts
R = np.fft.fft(r, len(r)+len(x)-1)
X = np.fft.fft(x, len(r)+len(x)-1)
Y = R*X
 

_renWin.SetSize(640, 480)
 
# do a quick check to make sure x and y are same length
if len(x) != len(y1):
    raise ValueError, "x and y vectors must be same length"
 
if len(x) != len(y2):
    raise ValueError, "x and y vectors must be same length"
 
# set up the x and y data arrays to be able to accept the data (code
# here adapted from the C++ of a vtk-users mailing list reply by Sander
# Niemeijer)
_xData = vtk.vtkDataArray.CreateDataArray(vtk.VTK_FLOAT)
_xData.SetNumberOfTuples(len(x))

_xData.SetNumberOfTuples(len(x))
 
_yData1 = vtk.vtkDataArray.CreateDataArray(vtk.VTK_FLOAT)
_yData1.SetNumberOfTuples(len(y1))
 
_yData2 = vtk.vtkDataArray.CreateDataArray(vtk.VTK_FLOAT)
_yData2.SetNumberOfTuples(len(y2))
 
_yData3 = vtk.vtkDataArray.CreateDataArray(vtk.VTK_FLOAT)
_yData3.SetNumberOfTuples(len(y3))
 
# put the data into the data arrays
for i in range(len(x)):

    Returns the Matrix, the temporary variables, and the terms for the polynomials
    """
    syms = syms.split()
    if len(syms) < dim:
        new_syms = []
        for i in range(dim - len(syms)):
            new_syms.append(syms[i%len(syms)] + str(i/len(syms)))
        syms.extend(new_syms)
    terms = []
    for i in range(order + 1):
        terms.extend(comb_w_rep(dim, i))
    rank = len(terms)

def gen_poly(points, order, syms):
    """Generates a polynomial using a Vandermonde system"""
    num_pts = len(points)
    if num_pts == 0:
        raise ValueError, "Must provide points"
    dim = len(points[0]) - 1
    if dim > len(syms):

            continue_prompt = self.continue_prompt.match(line.rstrip())
            output_prompt = self.output_prompt.match(line)
            if line.startswith("#"):
                insertions.append((len(curcode),
                                   [(0, Comment, line)]))
            elif input_prompt is not None:
                insertions.append((len(curcode),
                                   [(0, Generic.Prompt, input_prompt.group())]))
                curcode += line[input_prompt.end():]
            elif continue_prompt is not None:
                insertions.append((len(curcode),

                                   [(0, Generic.Prompt, continue_prompt.group())]))
                curcode += line[continue_prompt.end():]
            elif output_prompt is not None:
                insertions.append((len(curcode),
                                   [(0, Generic.Output, output_prompt.group())]))
                curcode += line[output_prompt.end():]
            else:

    Returns the Matrix, the temporary variables, and the terms for the polynomials
    """
    syms = syms.split()
    if len(syms) < dim:
        new_syms = []
        for i in range(dim - len(syms)):
            new_syms.append(syms[i%len(syms)] + str(i/len(syms)))
        syms.extend(new_syms)
    terms = []
    for i in range(order + 1):
        terms.extend(comb_w_rep(dim, i))
    rank = len(terms)

def gen_poly(points, order, syms):
    """Generates a polynomial using a Vandermonde system"""
    num_pts = len(points)
    if num_pts == 0:
        raise ValueError, "Must provide points"
    dim = len(points[0]) - 1
    if dim > len(syms):

def wkt_print_geoms(geoms):
    wkt = geos.WKTWriter()
    size = len(geoms)
    for i in range(size):
        tmp = wkt.write(geoms[i])
        print "[%d]" % i, tmp
 

    ################
    # Find centroid of each base geometry
    newgeoms = []
    for i in range(len(geoms)):
        newgeoms.append(geoms[i].getCentroid())
 
    print "\n","------- AND HERE ARE THEIR CENTROIDS -----"
    wkt_print_geoms(newgeoms)
 
    ################
    # BUFFER                           #
    ################
    newgeoms = []
    for i in range(len(geoms)):

    # CONVEX HULL                 #
    ################
    newgeoms = []
    for i in range(len(geoms)):
        newgeoms.append(geoms[i].convexHull())
 
    print "\n","--------HERE COMES THE HULLS----------"

    print "RELATIONAL OPERATORS"
    print "-------------------------------------------------------------------------------"
 
    size = len(geoms)
    ################
    # DISJOINT                          #
    ################

    """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.SPARQL, queryString)
    result = tupleQuery.evaluate(); 
    print "\nFound %i query results" % len(result)      
    for bindingSet in result:
        s = bindingSet[0]
        p = bindingSet[1]

    """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.SPARQL, queryString)
    result = tupleQuery.evaluate(); 
    print "\nFound %i query results" % len(result)    
    count = 0
    for bindingSet in result:
        print bindingSet

    """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.SPARQL, queryString)
    result = tupleQuery.evaluate(); 
    print "\nFound %i query results" % len(result)    
    count = 0
    for bindingSet in result:
        print bindingSet

    """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.SPARQL, queryString)
    result = tupleQuery.evaluate(); 
    print "\nFound %i query results" % len(result)    
    count = 0
    for bindingSet in result:
        print bindingSet

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("member")
        n = bindingSet.getValue("name")

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("member")
        n = bindingSet.getValue("name")

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("member")
        print "%s" %(p)

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("group")
        print "[",

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("group")
        print "[",

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("group")
        print "[",

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("path")
        print "[",

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("path")
        print "[",

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("path")
        print "[",

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("path")
        print "[",

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("path")
        print "[",

      """
    tupleQuery = conn.prepareTupleQuery(QueryLanguage.PROLOG, queryString)
    result = tupleQuery.evaluate();
    print "Found %i query results" % len(result)      
    for bindingSet in result:
        p = bindingSet.getValue("path")
        print "[",

    print "\nUsing getStatements() on common session; should find Valjean:"
    Valjean = common.createLiteral("Valjean")
    statements = common.getStatements(None, None, Valjean, None, False, 2)
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    print "\nUsing getStatements() on common session; should not find Kennedy:"
    Kennedy = dedicated.createLiteral("Kennedy")
    statements = common.getStatements(None, None, Kennedy,  None, False, 2)
    print "Number of results: %s" % len(statements)

        print s
    print "\nUsing getStatements() on dedicated session; should find Kennedys:"
    statements = dedicated.getStatements(None, None, Kennedy,  None, False, 2)
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    print "\nUsing getStatements() on dedicated session; should not find Valjean:"
    statements = dedicated.getStatements(None, None, Valjean,  None, False, 2)
    print "Number of results: %s" % len(statements)

    print "\nUsing getStatements() on common session; should find Valjean:"
    Valjean = common.createLiteral("Valjean")
    statements = common.getStatements(None, None, Valjean,  None, False, 2)
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    print "\nUsing getStatements() on common session; should not find Kennedys:"
    Kennedy = dedicated.createLiteral("Kennedy")
    statements = common.getStatements(None, None, Kennedy,  None, False, 2)
    print "Number of results: %s" % len(statements)

        print s
    print "\nUsing getStatements() on dedicated session; should not find Kennedys:"
    statements = dedicated.getStatements(None, None, Kennedy,  None, False, 2)
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    print "\nUsing getStatements() on dedicated session; should find Valjean:"
    statements = dedicated.getStatements(None, None, Valjean,  None, False, 2)
    print "Number of results: %s" % len(statements)

    print "\nUsing getStatements() on common session; should find Valjean:"
    Valjean = common.createLiteral("Valjean")
    statements = common.getStatements(None, None, Valjean,  None, False, 2)
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    print "\nUsing getStatements() on common session; should find Kennedys:"
    Kennedy = dedicated.createLiteral("Kennedy")
    statements = common.getStatements(None, None, Kennedy,  None, False, 2)
    print "Number of results: %s" % len(statements)

        print s
    print "\nUsing getStatements() on dedicated session; should find Kennedys:"
    statements = dedicated.getStatements(None, None, Kennedy,  None, False, 2)
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    print "\nUsing getStatements() on dedicated session; should find Valjean:"
    statements = dedicated.getStatements(None, None, Valjean,  None, False, 2)
    print "Number of results: %s" % len(statements)

    conn.add(path, base=baseURI, format=RDFFormat.RDFXML, contexts=None)
    statements = conn.getStatements(None, None, None, 'null', limit=10000)
    print "Two books, with one author as blank node in each book."
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    conn.remove(None, None, None)

    conn.add(path, base=baseURI, format=RDFFormat.RDFXML, contexts=None)
    statements = conn.getStatements(None, None, None, 'null', limit=10000)
    print "Two books, with one author identified by URI but in striped syntax in each book."
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    conn.remove(None, None, None)

    conn.add(path, base=baseURI, format=RDFFormat.RDFXML, contexts=None)
    statements = conn.getStatements(None, None, None, 'null', limit=10000)
    print "Two books, with one author linked by a URI."
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    conn.remove(None, None, None)

    conn.add(path, base=baseURI, format=RDFFormat.RDFXML, contexts=None)
    statements = conn.getStatements(None, None, None, 'null', limit=10000)
    print "Two books, with one author as a literal value."
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    conn.remove(None, None, None)

    hasChild = conn.createURI("http://www.franz.com/simple#has-child")
    print "\nUsing getStatements() find children of Ted Kennedy: three children."
    statements = conn.getStatements(TedKennedy, hasChild, None, 'null', limit=10000)
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
    # Write inept query to retrieve two children of Ted Kennedy.

 
    print "\nUsing getStatements(); children of Ted Kennedy: duplicate triples present."
    statements = conn.getStatements(TedKennedy, hasChild, None, 'null', limit=10000)
    print "Number of results: %s" % len(statements)
    for s in statements:
        print s
 

    starttime = time.clock()
    module = sys.modules[__name__]
 
    if len(sys.argv) == 1 or sys.argv[1] == "all":
        choices = range(1,24)
    else:
        choices = sys.argv[1:]   

        self.basemanip = BaseManipulation(self.robot,maxvelmult=maxvelmult)
        self.preprocess()
        # only the indices used by the TaskManipulation plugin should start with an 'i'
        graspdof = {'igraspdir':3,'igrasppos':3,'igrasproll':1,'igraspstandoff':1,'igrasppreshape':len(self.manip.GetGripperJoints()),'igrasptrans':12,'forceclosure':1,'grasptrans_nocol':12}
        self.graspindices = dict()
        self.totaldof = 0
        for name,dof in graspdof.iteritems():

    def has(self):
        return len(self.grasps) > 0 and len(self.graspindices) > 0 and self.grasper is not None
    def getversion(self):
        return 4
    def init(self,friction,avoidlinks,plannername=None):
        self.grasper = Grasper(self.robot,friction,avoidlinks,plannername)
        self.grasps = []

    def preprocess(self):
        with self.env:
            self.jointmaxlengths = zeros(len(self.robot.GetJoints()))
            for i,joint in enumerate(self.robot.GetJoints()):
                childlink = None
                if joint.GetFirstAttached() and self.robot.DoesAffect(joint.GetJointIndex(),joint.GetFirstAttached().GetIndex()):
                    childlink = joint.GetFirstAttached()

                            if childjoint.GetJointIndex() != joint.GetJointIndex():
                                if (childjoint.GetFirstAttached() and childjoint.GetFirstAttached().GetIndex() == childlink.GetIndex()) or (childjoint.GetSecondAttached() and childjoint.GetSecondAttached().GetIndex() == childlink.GetIndex()):
                                    vertices = r_[vertices,[childjoint.GetAnchor()-joint.GetAnchor()]]
                        self.jointmaxlengths[i] = sqrt(numpy.max(sum(vertices**2,1)-dot(vertices,joint.GetAxis(0))**2)) if len(vertices) > 0 else 0
    def autogenerate(self,options=None):
        # disable every body but the target and robot
        friction = None

        updateenv=False
        if options is not None:
            if options.preshapes is not None:
                preshapes = zeros((0,len(self.manip.GetGripperJoints())))
                for preshape in options.preshapes:
                    preshapes = r_[preshapes,[array([float(s) for s in preshape.split()])]]
            if options.boxdelta is not None:

        approachgraphs = [self.env.plot3(points=gapproachrays[:,0:3],pointsize=5,colors=array((1,0,0))),
                          self.env.drawlinelist(points=reshape(c_[gapproachrays[:,0:3],gapproachrays[:,0:3]+0.005*gapproachrays[:,3:6]],(2*N,3)),linewidth=4,colors=array((1,0,0,1)))]
        contactgraph = None
        totalgrasps = N*len(preshapes)*len(rolls)*len(standoffs)
        counter = 0
        self.grasps = []
        statesaver = self.robot.CreateRobotStateSaver()

                            Tlocalgrasp_nocol = dot(linalg.inv(self.target.GetTransform()),Tgrasp_nocol)
                            self.robot.SetJointValues(finalconfig[0])
                            if updateenv:
                                contactgraph = self.drawContacts(contacts) if len(contacts) > 0 else None
                                self.env.UpdatePublishedBodies()
                        grasp[self.graspindices.get('igrasptrans')] = reshape(transpose(Tlocalgrasp[0:3,0:4]),12)
                        grasp[self.graspindices.get('grasptrans_nocol')] = reshape(transpose(Tlocalgrasp_nocol[0:3,0:4]),12)
                        grasp[self.graspindices.get('forceclosure')] = mindist
                        if mindist > forceclosurethreshold:
                            print 'found good grasp',len(self.grasps),'config: ',array(finalconfig[0])[self.manip.GetGripperJoints()]

                        grasps = self.grasps
                    graspingnoise=options.graspingnoise
                for i,grasp in enumerate(grasps):
                    print 'grasp %d/%d'%(i,len(grasps))
                    try:
                        with self.env:
                            #self.env.SetDebugLevel(DebugLevel.Verbose)
                            contacts,finalconfig,mindist,volume = self.testGrasp(grasp=grasp,translate=True,forceclosure=True,graspingnoise=graspingnoise)
                            #contacts,finalconfig,mindist,volume = self.runGrasp(grasp=grasp,translate=True,forceclosure=True)
                            if mindist == 0:
                                print 'grasp is not in force closure!'
                            contactgraph = self.drawContacts(contacts) if len(contacts) > 0 else None

            validindices = []
            self.robot.SetActiveManipulator(self.manip)
            report = CollisionReport()
            for i in range(startindex,len(self.grasps)):
                grasp = self.grasps[i]
                self.setPreshape(grasp)
                Tglobalgrasp = self.getGlobalGraspTransform(grasp,collisionfree=True)

                        continue
                validgrasps.append(grasp)
                validindices.append(i)
                if len(validgrasps) == returnnum:
                    return validgrasps,validindices
            return validgrasps,validindices
 

        validgrasps = []
        validindices = []
        if randomgrasps:
            order = startindex+random.permutation(len(self.grasps)-startindex)
        else:
            order = range(startindex,len(self.grasps))
        for i in order:

            for grasp in self.grasps:
                contacts,finalconfig,mindist,volume = self.runGrasp(grasp=grasp,translate=True,forceclosure=False)
                # find closest contact to center of object
                contactdists.append(numpy.min(sum((contacts[:,0:3]-tile(ab.pos(),(len(contacts),1)))**2,1)))
            order = argsort(array(contactdists))
            self.grasps = self.grasps[order]
 

                    collision, info = self.env.CheckCollisionRays(rays,self.target)
                    # make sure all normals are the correct sign: pointing outward from the object)
                    newinfo = info[collision,:]
                    if len(newinfo) > 0:
                        newinfo[sum(rays[collision,3:6]*newinfo[:,3:6],1)>0,3:6] *= -1
                        approachrays = r_[approachrays,newinfo]
                if normalanglerange > 0:
                    theta,pfi = SpaceSampler().sampleS2(angledelta=directiondelta)
                    dirs = c_[cos(theta),sin(theta)*cos(pfi),sin(theta)*sin(pfi)]
                    dirs = array([dir for dir in dirs if arccos(dir[2])<=normalanglerange]) # find all dirs within normalanglerange
                    if len(dirs) == 0:

                    newapproachrays = zeros((0,6))
                    for approachray in approachrays:
                        R = rotationMatrixFromQuat(quatRotateDirection(array((0,0,1)),approachray[3:6]))
                        newapproachrays = r_[newapproachrays,c_[tile(approachray[0:3],(len(dirs),1)),dot(dirs,transpose(R))]]
                    approachrays = newapproachrays
                return approachrays
        finally:
            # restore the collision checker
            if cc is not None:
                self.env.SetCollisionChecker(cc)
    def computeSphereApproachRays(self,delta=0.1,normalanglerange=0,directiondelta=0.4):
        with self.target:
            self.target.SetTransform(eye(4))
            dirs = newinfo[:,0:3]-tile(p,(len(newinfo),1))

    def drawContacts(self,contacts,conelength=0.03,transparency=0.5):
        angs = linspace(0,2*pi,10)
        conepoints = r_[[[0,0,0]],conelength*c_[self.grasper.friction*cos(angs),self.grasper.friction*sin(angs),ones(len(angs))]]
        triinds = array(c_[zeros(len(angs)),range(2,1+len(angs))+[1],range(1,1+len(angs))].flatten(),int)
        allpoints = zeros((0,3))
        for c in contacts:
            R = rotationMatrixFromQuat(quatRotateDirection(array((0,0,1)),c[3:6]))

def tdone():
    global failed
    if len(failed) > 0:
        print "\nFailed tests:"
        for fail in failed:
            print "  ", fail
    else:

 
    s = (1.2, 2, -3.4, 4.5, 5.6)
    r = io.complex13(s)
    if len(r) == len(s):
        tresult(r)
    else:
        ok = 0
        tresult("-")
 
    s = [1.2, 2, -3.4, 4.5, 5.6]
    r = io.complex14(s)
    if len(r) == len(s):

 
    s = (1, 0, 1, 1, 0, 3, 1, 1, 1)
    r = io.complex15(s)
    if len(r) == len(s):
        tresult(r)
    else:
        ok = 0

 
    s = (1.2, 2, -3.4, 4.5, 5.6)
    r = io.complex22(s)
    if len(r) == len(s):
        tresult(r)
    else:
        ok = 0
        tresult("-")
 
    s = [1.2, 2, -3.4, 4.5, 5.6]
    r = io.complex23(s)
    if len(r) == len(s):

 
    s = (1, 0, 1, 1, 0, 3, 1, 1, 1, 1)
    r = io.complex24(s)
    if len(r) == len(s):
        tresult(r)
    else:
        ok = 0

 
    s = (1.2, 2, -3.4, 4.5, 5.6)
    r = io.complex31(s)
    if len(r) == len(s):
        tresult(r)
    else:
        ok = 0
        tresult("-")
 
    s = [1.2, 2, -3.4, 4.5, 5.6]
    r = io.complex32(s)
    if len(r) == len(s):

 
    s = (1, 0, 1, 3, 0)
    r = io.complex33(s)
    if len(r) == len(s):
        tresult(r)
    else:
        ok = 0

 
    s = (1L, 2L, -3L, 4L, 5L)
    r = io.complex13(s)
    if len(r) == len(s):
        tresult(r)
    else:
        ok = 0
        tresult("-")
 
    s = [1L, 2L, -3L, 4L, 5L]
    r = io.complex14(s)
    if len(r) == len(s):

 
    s = (1L, 0L, 1L, 1L, 0L, 3L, 1L, 1L, 1L)
    r = io.complex15(s)
    if len(r) == len(s):
        tresult(r)
    else:
        ok = 0

            tresult("-")
 
        r = io.context2(5, ctxt)
        if len(r) == 10:
            tresult("+")
        else:
            ok = 0