# How to use functions method in autopy

Best Python code snippet using autopy

dfinite_symbolic.py

Source:dfinite_symbolic.py

`1# coding: utf-82r"""3Database of annihilators4Database for annihilating operators, i.e. elements of certain OreAlgebras, for various discrete and differentiable5symbolic functions.6The following discrete functions are supported:7 - binomial(an+b, cn+d) where a,b,c,d are fixed rational numbers and n is the variable8 - factorial(n)9 - harmonic_number(n)10The following differentiable functions are supported:11 - Trigonometric functions: sin(x), cos(x), arcsin(x), arccos(x), arctan(x), arccsc(x), arcsec(x)12 - Hyperbolic functions: sinh(x), cosh(x), arcsinh(x), arctanh(x), arccsch(x)13 - Logarithmic functions: exp(x), log(x), dilog(x)14 - Airy functions: airy_ai(x), airy_bi(x), airy_ai_prime(x), airy_bi_prime(x)15 - Bessel functions: bessel_I(k,x), bessel_J(k,x), bessel_K(k,x), bessel_Y(k,x), spherical_bessel_J(k,x) where k is a fixed16 rational number and x is the variable17 - Error functions: erf(x), erfc(x), erfi(x)18 - Integrals: exp_integral_e(k,x), exp_integral_ei(x), sin_integral(x), cos_integral(x), sinh_integral(x), cosh_integral(x)19 - Other: sqrt(x), elliptic_ec(x), elliptic_kc(x)20 21AUTHOR:22- Clemens Hofstadler (2018-03-01)23 24"""25#############################################################################26# Copyright (C) 2018, Clemens Hofstadler (clemens.hofstadler@liwest.at). #27# #28# Distributed under the terms of the GNU General Public License (GPL) #29# either version 2, or (at your option) any later version #30# #31# http://www.gnu.org/licenses/ #32#############################################################################33from __future__ import absolute_import, division34import sage.functions.airy35import sage.functions.bessel36import sage.functions.error37import sage.functions.exp_integral38import sage.functions.hyperbolic39import sage.functions.log40import sage.functions.other41import sage.functions.special42import sage.functions.trig43from sage.rings.all import QQ44from operator import pow45def symbolic_database(A, f, inner = None, k = 0):46 r"""47 Tries to return an annihilating operator of a symbolic operator `f`, i.e. an element from a (suitable) OreAlgebra `A`48 that represents a differential/recurrence equation for the symoblic epxression ``f(x)``49 50 INPUT:51 52 - `A` -- an OreAlgebra from which the annihilating operator for `f` should come from53 54 - `f` - a symbolic operator. It is important that not the symbolic expression itself is handled to this method but only55 the operator (which can be accessed via the command ``.operator()``56 57 - ``inner`` (default ``None``) -- for differentiable functions an inner function can be handed over. Then not an operator58 for f(x) but for f(inner) is returned. However ``inner`` has to be a linear function, i.e. of the form u*x + v for59 u,v in QQ. For discrete functions ``inner`` does not have any impact.60 61 - `k` (default 0) -- a rational number that has to be handed over if the symolic operator `f` depends on two variables (such as binomial(k,n) or bessel_I(k,x) ) because only operators for univariate functions can be returned and 62 therefore one variable has to be assigned with a certain value `k`63 64 OUTPUT:65 66 An element from the OreAlgebra `A`, that represents a differential/recurrence equation which annihilates f(x) or if67 ``inner`` is not ``None`` an element from `A` which annihilates f(inner).68 69 EXAMPLES::70 71 #discrete case72 sage: from ore_algebra import *73 sage: from ore_algebra.dfinite_symbolic import symbolic_database74 sage: A = OreAlgebra(QQ['n'],'Sn')75 sage: n = var('n')76 sage: f = harmonic_number(n).operator()77 sage: symbolic_database(A,f)78 (n + 2)*Sn^2 + (-2*n - 3)*Sn + n + 179 sage: g = binomial(5,n).operator()80 sage: symbolic_database(A,g,None,5)81 (n + 1)*Sn + n - 582 83 #differential case84 sage: B = OreAlgebra(QQ['x'],'Dx')85 sage: x = var('x')86 sage: f = sin(x).operator()87 sage: symbolic_database(B,f)88 Dx^2 + 189 sage: g = log(3*x+4).operator()90 sage: symbolic_database(B,g,3*x+4)91 (3*x + 4)*Dx^2 + 3*Dx92 sage: h = bessel_I(4,2*x+1).operator()93 sage: symbolic_database(B,h,2*x+1,4)94 (4*x^2 + 4*x + 1)*Dx^2 + (4*x + 2)*Dx - 16*x^2 - 16*x - 6895 96 """97 n = A.is_S()98 k = A(k)99 #sequences100 if n:101 Sn = A.gen()102 #factorial103 if isinstance(f,sage.functions.other.Function_factorial):104 return A(Sn - (n+1))105 #harmonic_number106 elif isinstance(f,sage.functions.log.Function_harmonic_number_generalized):107 return A( (n+2)*Sn**2 - (2*n+3)*Sn + (n+1) )108 #binomial109 elif isinstance(f,sage.functions.other.Function_binomial):110 #(k choose n) - k fixed, n variable111 if k in QQ:112 return A((n+1)*Sn - (k-n))113 #(a*n+b choose c*n+d) - a,b,c,d fixed, n variable114 else:115 k = k.constant_coefficient()116 f1 = prod(inner+i for i in range(1,inner[1]+1))117 f2 = prod(k+i for i in range(1,k[1]+1))118 f3 = prod(inner - k + i for i in range(1,inner[1]-k[1]+1))119 return A(f2*f3*Sn - f1)120 else:121 raise NotImplementedError122 123 #functions124 else:125 Dx = A.gen()126 if inner:127 x = A(inner)128 d = A(inner.derivative())129 else:130 x = A.base_ring().gen()131 d = 1 #x.derivative()132 133 #sin134 if isinstance(f,sage.functions.trig.Function_sin):135 return A(Dx**2 + d**2)136 #cos137 elif isinstance(f,sage.functions.trig.Function_cos):138 return A(Dx**2 + d**2)139 #tan140 elif isinstance(f,sage.functions.trig.Function_tan):141 raise TypeError("Tan is not D-finite")142 #arcsin143 elif isinstance(f,sage.functions.trig.Function_arcsin):144 return A((1-x**2)*Dx**2 - d*x*Dx)145 #arccos146 elif isinstance(f,sage.functions.trig.Function_arccos):147 return A((1-x**2)*Dx**2 - d*x*Dx)148 #arctan149 elif isinstance(f,sage.functions.trig.Function_arctan):150 return A((x**2+1)*Dx**2 + d*2*x*Dx)151 #sinh152 elif isinstance(f,sage.functions.hyperbolic.Function_sinh):153 return A(Dx**2 - d**2)154 #cosh155 elif isinstance(f,sage.functions.hyperbolic.Function_cosh):156 return A(Dx**2 - d**2)157 #arcsinh158 elif isinstance(f,sage.functions.hyperbolic.Function_arcsinh):159 return A((1+x**2)*Dx**2 + d*x*Dx)160 #arccosh161 elif isinstance(f,sage.functions.hyperbolic.Function_arccosh):162 raise TypeError("ArcCosh is not D-finite")163 #arctanh164 elif isinstance(f,sage.functions.hyperbolic.Function_arctanh):165 return A((1-x**2)*Dx**2 - 2*d*x*Dx)166 #exp167 elif isinstance(f,sage.functions.log.Function_exp):168 return A(Dx - d)169 #log170 elif isinstance(f,sage.functions.log.Function_log1):171 return A(x*Dx**2 + d*Dx)172 #sqrt173 elif f == pow:174 return A(-2*x*Dx + d)175 #airy_ai176 elif isinstance(f,sage.functions.airy.FunctionAiryAiSimple):177 return A(Dx**2 - d**2*x)178 #airy_ai_prime179 elif isinstance(f,sage.functions.airy.FunctionAiryAiPrime):180 return A(x*Dx**2 - d*Dx - d**2*x**2)181 #airy_bi182 elif isinstance(f,sage.functions.airy.FunctionAiryBiSimple):183 return A(Dx**2 - d**2*x)184 #airy_bi_prime185 elif isinstance(f,sage.functions.airy.FunctionAiryBiPrime):186 return A(x*Dx**2 - d*Dx - (d*x)**2)187 #arccsc188 elif isinstance(f,sage.functions.trig.Function_arccsc):189 return A(x*(1-x**2)*Dx**2 - (2*x**2-1)*d*Dx)190 #arccsch191 elif isinstance(f,sage.functions.hyperbolic.Function_arccsch):192 return A(x*(x**2+1)*Dx**2 + (2*x**2+1)*d*Dx)193 #arcsec194 elif isinstance(f,sage.functions.trig.Function_arcsec):195 return A(x*(1-x**2)*Dx**2 - (2*x**2-1)*d*Dx)196 #bessel_I197 elif isinstance(f,sage.functions.bessel.Function_Bessel_I):198 return A( x**2*Dx**2 + d*x*Dx - d**2*(x**2 + k**2) )199 #bessel_J200 elif isinstance(f,sage.functions.bessel.Function_Bessel_J):201 return A( x**2*Dx**2 + d*x*Dx + d**2*(x**2 - k**2) )202 #bessel_Y203 elif isinstance(f,sage.functions.bessel.Function_Bessel_Y):204 return A( x**2*Dx**2 + d*x*Dx + d**2*(x**2 - k**2) )205 #bessel_K206 elif isinstance(f,sage.functions.bessel.Function_Bessel_K):207 return A( x**2*Dx**2 + d*x*Dx - d**2*(x**2 + k**2) )208 #sherical_bessel_Jzz209 elif isinstance(f,sage.functions.bessel.SphericalBesselJ):210 return A( x**2*Dx**2 + 2*d*x*Dx + d**2*(x**2 - k*(k+1)) )211 #erf (error function)212 elif isinstance(f,sage.functions.error.Function_erf):213 return A( Dx**2 + 2*d*x*Dx )214 #erfc (complementary error function)215 elif isinstance(f,sage.functions.error.Function_erfc):216 return A( Dx**2 + 2*d*x*Dx )217 #erfi (imaginary error function)218 elif isinstance(f,sage.functions.error.Function_erfi):219 return A( Dx**2 - 2*d*x*Dx )220 #dilog221 elif isinstance(f,sage.functions.log.Function_dilog):222 return A( x*(1-x)*Dx**3 + d*(2-3*x)*Dx**2 - d**2*Dx )223 #exp_integral_e224 elif isinstance(f,sage.functions.exp_integral.Function_exp_integral_e):225 return A( x*Dx**2 + d*(x-k+2)*Dx + d**2*(1-k) )226 #exp_integral_ei (Ei)227 elif isinstance(f, sage.functions.exp_integral.Function_exp_integral):228 return A( x*Dx**3 + 2*d*Dx**2 - d**2*x*Dx )229 #sin_integral230 elif isinstance(f,sage.functions.exp_integral.Function_sin_integral):231 return A( x*Dx**3 + 2*d*Dx**2 + d**2*x*Dx )232 #cos_integral233 elif isinstance(f,sage.functions.exp_integral.Function_cos_integral):234 return A( x*Dx**3 + 2*d*Dx**2 + d**2*x*Dx )235 #sinh_integral236 elif isinstance(f,sage.functions.exp_integral.Function_sinh_integral):237 return A ( x*Dx**3 + 2*d*Dx**2 - d**2*x*Dx )238 #cosh_integral239 elif isinstance(f,sage.functions.exp_integral.Function_sinh_integral):240 return A( x*Dx**3 + 2*d*Dx**2 - d**2*x*Dx )241 #elliptic_ec (complete elliptic integral of second kind) - problems with computing the derivative242 elif isinstance(f,sage.functions.special.EllipticEC):243 return A( (1-x)*x*Dx**2 + d*(1-x)*Dx + d**2*QQ(1./4) )244 #elliptic_kc (complete elliptic integral of first kind) - problems with computing the derivative245 elif isinstance(f,sage.functions.special.EllipticKC):246 return A( (1-x)*x*Dx**2 + d*(1-2*x)*Dx - d**2*QQ(1./4) )247 else:...`

dsp.py

Source:dsp.py

`1import numpy as np2from scipy import signal 3import emd4from scipy import stats5# helper function to flatten lists6def flatten(input):7 new_list = []8 for i in input:9 for j in i:10 new_list.append(j)11 return new_list12def axes_to_list(axes_data: dict) -> list:13 """helper method to convert a dict of sensor axis graphs to a 2d array for graphing14 """15 axes_tuples = axes_data.items()16 axes_list = [axes[1].tolist() for axes in axes_tuples]17 return axes_list18# retrieve the next imf of the input signal. Use this on the prior computed imf or base signal19def get_next_imf(x, zoom=None, sd_thresh=0.1):20 proto_imf = x.copy() # Take a copy of the input so we don't overwrite anything21 continue_sift = True # Define a flag indicating whether we should continue sifting22 niters = 0 # An iteration counter23 if zoom is None:24 zoom = (0, x.shape[0])25 # Main loop - we don't know how many iterations we'll need so we use a ``while`` loop26 while continue_sift:27 niters += 1 # Increment the counter28 # Compute upper and lower envelopes29 upper_env = emd.utils.interp_envelope(proto_imf, mode='upper')30 lower_env = emd.utils.interp_envelope(proto_imf, mode='lower')31 # Compute average envelope32 avg_env = (upper_env+lower_env) / 233 # Should we stop sifting?34 stop, val = emd.sift.sd_stop(proto_imf-avg_env, proto_imf, sd=sd_thresh)35 # Remove envelope from proto IMF36 proto_imf = proto_imf - avg_env37 # and finally, stop if we're stopping38 if stop:39 continue_sift = False40 # Return extracted IMF41 return proto_imf42def frequency_domain_graph_y(sampling_freq, lenX):43 N = lenX44 T = 1 / sampling_freq45 freq_space = np.linspace(0.0, 1.0/(2.0*T), N//2)46 return freq_space.tolist()47def generate_features(draw_graphs, raw_data, axes, sampling_freq, **kwargs):48 # features is a 1D array, reshape so we have a matrix with one raw per axis49 raw_data = raw_data.reshape(int(len(raw_data) / len(axes)), len(axes))50 # results are the first 3 imfs and their residuals51 # storing as a dict in [imf][axis] order to match format expected by dsp server graphs52 result_functions = {'imf0' : {}, 'imf1' : {}, 'imf2' : {}, 'res0' : {}, 'res1' : {}, 'res2' : {}}53 # split out the data from all axes54 for ax in range(0, len(axes)):55 X = []56 for ix in range(0, raw_data.shape[0]):57 X.append(raw_data[ix][ax])58 # X now contains only the current axis59 fx = np.array(X)60 imf = []61 res = []62 # get first imfs and residuals63 result_functions['imf0'][axes[ax]] = get_next_imf(fx)64 result_functions['res0'][axes[ax]] = fx - result_functions['imf0'][axes[ax]]65 result_functions['imf1'][axes[ax]] = get_next_imf(result_functions['res0'][axes[ax]])66 result_functions['res1'][axes[ax]] = result_functions['res0'][axes[ax]] - result_functions['imf1'][axes[ax]]67 result_functions['imf2'][axes[ax]] = get_next_imf(result_functions['res1'][axes[ax]])68 result_functions['res2'][axes[ax]] = result_functions['res1'][axes[ax]] - result_functions['imf2'][axes[ax]]69 # compute statistical features for imfs and residuals70 # features is a fixed size 1x48 dimension list matching order of Sensorless Diagnosis dataset71 features = []72 # mean73 for ax in range(0, len(axes)):74 features.append(np.mean(result_functions['imf0'][axes[ax]]))75 features.append(np.mean(result_functions['imf1'][axes[ax]]))76 features.append(np.mean(result_functions['imf2'][axes[ax]]))77 for ax in range(0, len(axes)):78 features.append(np.mean(result_functions['res0'][axes[ax]]))79 features.append(np.mean(result_functions['res1'][axes[ax]]))80 features.append(np.mean(result_functions['res2'][axes[ax]]))81 # stddev82 for ax in range(0, len(axes)):83 features.append(np.std(result_functions['imf0'][axes[ax]]))84 features.append(np.std(result_functions['imf1'][axes[ax]]))85 features.append(np.std(result_functions['imf2'][axes[ax]]))86 for ax in range(0, len(axes)):87 features.append(np.std(result_functions['res0'][axes[ax]]))88 features.append(np.std(result_functions['res1'][axes[ax]]))89 features.append(np.std(result_functions['res2'][axes[ax]]))90 # skew91 for ax in range(0, len(axes)):92 features.append(stats.skew(result_functions['imf0'][axes[ax]]))93 features.append(stats.skew(result_functions['imf1'][axes[ax]]))94 features.append(stats.skew(result_functions['imf2'][axes[ax]]))95 for ax in range(0, len(axes)):96 features.append(stats.skew(result_functions['res0'][axes[ax]]))97 features.append(stats.skew(result_functions['res1'][axes[ax]]))98 features.append(stats.skew(result_functions['res2'][axes[ax]]))99 # kurtosis100 for ax in range(0, len(axes)):101 features.append(stats.kurtosis(result_functions['imf0'][axes[ax]]))102 features.append(stats.kurtosis(result_functions['imf1'][axes[ax]]))103 features.append(stats.kurtosis(result_functions['imf2'][axes[ax]]))104 for ax in range(0, len(axes)):105 features.append(stats.kurtosis(result_functions['res0'][axes[ax]]))106 features.append(stats.kurtosis(result_functions['res1'][axes[ax]]))107 features.append(stats.kurtosis(result_functions['res2'][axes[ax]]))108 # conditionally provide graphs109 graphs = []110 if (draw_graphs):111 graphs.append({112 'name': 'IMF0',113 'X': axes_to_list(result_functions['imf0']),114 'y': np.linspace(0.0, raw_data.shape[0] * (1 / sampling_freq) * 1000, raw_data.shape[0] + 1).tolist(),115 'suggestedYMin': min(flatten(result_functions['imf0'].values())),116 'suggestedYMax': max(flatten(result_functions['imf0'].values())),117 })118 graphs.append({119 'name': 'RES0',120 'X': axes_to_list(result_functions['res0']),121 'y': np.linspace(0.0, raw_data.shape[0] * (1 / sampling_freq) * 1000, raw_data.shape[0] + 1).tolist(),122 'suggestedYMin': min(flatten(result_functions['res0'].values())),123 'suggestedYMax': max(flatten(result_functions['res0'].values()))124 })125 graphs.append({126 'name': 'IMF1',127 'X': axes_to_list(result_functions['imf1']),128 'y': np.linspace(0.0, raw_data.shape[0] * (1 / sampling_freq) * 1000, raw_data.shape[0] + 1).tolist(),129 'suggestedYMin': min(flatten(result_functions['imf1'].values())),130 'suggestedYMax': max(flatten(result_functions['imf1'].values()))131 })132 graphs.append({133 'name': 'RES1',134 'X': axes_to_list(result_functions['res1']),135 'y': np.linspace(0.0, raw_data.shape[0] * (1 / sampling_freq) * 1000, raw_data.shape[0] + 1).tolist(),136 'suggestedYMin': min(flatten(result_functions['res1'].values())),137 'suggestedYMax': max(flatten(result_functions['res1'].values()))138 })139 graphs.append({140 'name': 'IMF2',141 'X': axes_to_list(result_functions['imf2']),142 'y': np.linspace(0.0, raw_data.shape[0] * (1 / sampling_freq) * 1000, raw_data.shape[0] + 1).tolist(),143 'suggestedYMin': min(flatten(result_functions['imf2'].values())),144 'suggestedYMax': max(flatten(result_functions['imf2'].values()))145 })146 graphs.append({147 'name': 'RES2',148 'X': axes_to_list(result_functions['res2']),149 'y': np.linspace(0.0, raw_data.shape[0] * (1 / sampling_freq) * 1000, raw_data.shape[0] + 1).tolist(),150 'suggestedYMin': min(flatten(result_functions['res2'].values())),151 'suggestedYMax': max(flatten(result_functions['res2'].values()))152 })153 return {154 'features': features,155 'graphs': graphs...`

build_glob.py

Source:build_glob.py

`1#! /usr/bin/env python2###3#4# build_glob.py : Build the global_functions.h and global_functions.c5# files which are required to implement the user6# interface to global variables now that thread specific7# data (TSD) is used to emulate global state.8#9# See Copyright for the status of this software.10# Gary.Pennington@sun.com11###12import os, string13class globvar:14 def __init__(self, type, name):15 self.type=type16 self.name=name17def striplinesep(line):18 while line and line[-1] in ('\r','\n'):19 line = line[:-1]20 return line21def writeline(file, line=None):22 if line:23 file.write(line)24 file.write("\n")25if __name__ == "__main__":26 globals={}27 global_data=open("global.data").readlines()28 global_code=open("globals.c").readlines()29 global_hdr=open("include/libxml/globals.h").readlines()30 global_functions_hdr=open("include/libxml/globals.h", "w+")31 global_functions_impl=open("globals.c", "w+")32 #33 # Rebuild the beginning of the file up to the34 # Automatically generated string35 # 36 for line in global_hdr:37 line = striplinesep(line)38 if line == " * Automatically generated by build_glob.py.":39 break40 writeline(global_functions_hdr, line)41 writeline(global_functions_hdr, " * Automatically generated by build_glob.py.")42 writeline(global_functions_hdr, " * Do not modify the previous line.")43 writeline(global_functions_hdr, " */")44 writeline(global_functions_hdr)45 for line in global_code:46 line = striplinesep(line)47 if line == " * Automatically generated by build_glob.py.":48 break49 writeline(global_functions_impl, line)50 writeline(global_functions_impl, " * Automatically generated by build_glob.py.")51 writeline(global_functions_impl, " * Do not modify the previous line.")52 writeline(global_functions_impl, " */")53 writeline(global_functions_impl)54 # Now process the data and write it to the appropriate output file55 for line in global_data:56 if line[0]=='#':57 continue58 line = striplinesep(line)59 fields = string.split(line, ",")60 # Update the header file61 writeline(global_functions_hdr)62 global_functions_hdr.write("extern "+fields[0]+" *")63 if fields[2]:64 global_functions_hdr.write("(*")65 global_functions_hdr.write("__"+fields[1]+"(void)")66 if fields[2]:67 global_functions_hdr.write(")"+fields[2])68 writeline(global_functions_hdr,";")69 writeline(global_functions_hdr, "#ifdef LIBXML_THREAD_ENABLED")70 writeline(global_functions_hdr,"#define "+fields[1]+" \\")71 writeline(global_functions_hdr,"(*(__"+fields[1]+"()))")72 writeline(global_functions_hdr,"#else")73 if fields[2]:74 writeline(global_functions_hdr,"LIBXML_DLL_IMPORT extern "+fields[0]+" "+fields[1]+fields[2]+";")75 else:76 writeline(global_functions_hdr,"LIBXML_DLL_IMPORT extern "+fields[0]+" "+fields[1]+";")77 writeline(global_functions_hdr,"#endif")78 # set/get for per-thread global defaults79 if fields[3]:80 writeline(global_functions_hdr,fields[0]+" "+fields[1][:3]+"ThrDef"+fields[1][3:]+"("+fields[0]+" v);")81 # Update the implementation file82 writeline(global_functions_impl)83# writeline(global_functions_impl, "extern "+fields[0]+" "+fields[1]+";")84 writeline(global_functions_impl, "#undef\t"+fields[1])85 writeline(global_functions_impl, fields[0]+" *")86 if fields[2]:87 global_functions_impl.write("(*")88 global_functions_impl.write("__"+fields[1]+"(void)")89 if fields[2]:90 writeline(global_functions_impl, ")[]")91 writeline(global_functions_impl, " {")92 writeline(global_functions_impl, " if (IS_MAIN_THREAD)")93 writeline(global_functions_impl, "\treturn (&"+fields[1]+");")94 writeline(global_functions_impl, " else")95 writeline(global_functions_impl, "\treturn (&xmlGetGlobalState()->"+fields[1]+");")96 writeline(global_functions_impl, "}")97 # set/get for per-thread global defaults98 if fields[3]:99 writeline(global_functions_impl,fields[0]+" "+fields[1][:3]+"ThrDef"+fields[1][3:]+"("+fields[0]+" v) {")100 writeline(global_functions_impl," "+fields[0]+" ret;");101 writeline(global_functions_impl," xmlMutexLock(xmlThrDefMutex);")102 writeline(global_functions_impl," ret = "+fields[1][:3]+fields[1][3:]+"ThrDef;")103 writeline(global_functions_impl," "+fields[1][:3]+fields[1][3:]+"ThrDef = v;")104 writeline(global_functions_impl," xmlMutexUnlock(xmlThrDefMutex);")105 writeline(global_functions_impl," return ret;")106 writeline(global_functions_impl,"}")107 # Terminate the header file with appropriate boilerplate108 writeline(global_functions_hdr)109 writeline(global_functions_hdr, "#ifdef __cplusplus")110 writeline(global_functions_hdr, "}")111 writeline(global_functions_hdr, "#endif")112 writeline(global_functions_hdr)...`

## Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

## YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

## Run autopy automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

## Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!