def binByPosition(self, rbins, dbins, string): ''' This is not a strictly accurate title. We are binning by position then spitting back ages within those position bins ''' val2bin = self.params[string] nr = len(rbins)-1 nd = len(dbins)-1 out = [] eout = [] for i in range(nr): for j in range(nd): # pdb.set_trace() ind = (self.ra*cosdg(self.d31) > rbins[i]) & (self.ra*cosdg(self.d31) <= rbins[i+1]) & (self.dec > dbins[j]) & (self.dec <= dbins[j+1]) & (self.params['PIXAV'] >= 0) z = val2bin[ind] if len(z) > 10: out.append(np.mean(z[z == z])) #eout.append(0) eout.append(np.std(z[z == z])/np.sqrt(len(z))) else: out.append(np.nan) eout.append(np.nan) return np.array(out), np.array(eout)
def rot_x_matrix( degrees ): r = identity( 3, 'd' ) r[1][1] = cosdg( degrees ) r[1][2] = -sindg( degrees ) r[2][1] = sindg( degrees ) r[2][2] = cosdg( degrees ) return r
def v_hel(z, ra, dec, mjd, aband, longitude=keck_long, latitude=keck_lat, altitude=keck_alt, tanplane=False, delim=":"): """ Calculate the heliocentric velocity of stars given their redshift (z), RA and DEC, date of observation (mjd) and A-band correction Default longitude and latitude correspond to Keck Required arguments: - z: redshift - ra: right ascension as string or degree - dec: declination as string or degree - mjd: Julian Date of observation - abad: Aband correction Optional arguments - longitude: longitude of observatory - latitude: latitude of observatory - altitude: altitude of observatory - tanplane: are your positions already in the tangential plane - delim: delimiter if your positions are a string Note: helcorr.py, and its dependencies, are part of Sergey Koposov's astrolibpy library. I am not aware of an astropy equivalent, but there may well be one It is being imported here so as to not muck up all the other things that don't need it """ from helcorr import helcorr if isinstance(ra, str): ra_deg, dec_deg = hms2deg(ra, dec, delim=delim) else: ra_deg = ra dec_deg = dec if ~tanplane: ra_deg *= cosdg(d31) return (z * c) - (aband * c) - helcorr(longitude, latitude, altitude, ra_deg, dec_deg, mjd)[0]
def write_xml(self, filename, lat): if self.dim != lat.dim: ERROR("dimension mismatch between wavevector and lattice") with codecs.open(filename, "w", "utf-8") as f: f.write('<?xml version="1.0" encoding="UTF-8"?>\n') f.write("<WaveVector>\n") f.write(tagged("Comment", lat.name)) f.write(tagged("NumberOfSites", len(lat.sites))) f.write(tagged("NumberOfWaveVectors", self.nk)) f.write( "<!-- <RK> [phase(cos)] [phase(sin)] [isite] [kindx] </RK> -->\n" ) for ik in range(self.nk): k = self.ks[:, ik] for site in lat.sites: sid = site.id coord = site.coord phase = 0 for d in range(self.dim): phase += coord[d] * k[d] / float(lat.size[d]) c = spsp.cosdg(360 * phase) s = spsp.sindg(360 * phase) f.write(tagged("RK", [c, s, sid, ik])) f.write("</WaveVector>\n")
def keck_constants(): return { "latitude": 19.8283, "longitude": 360.0 - 155.478, "altitude": 4160.0, "declination": 41.269, "right_ascension": 10.68 * cosdg(41.269), }
def rotate( self, degrees ): """rotate this vector by given degrees and return as new vector """ # cosine vector is this vector multiplied by cosine of angle cosine = self.multiply( cosdg(degrees) ) # sine vector is cross product of this vector and normalized given # vector, multiplied by sine of angle sine = self.cross().multiply( sindg(degrees) ) return cosine.add( sine )
def generate(param): dim = 2 L = get_as_list(param, "L", extendto=dim) bc = get_as_list(param, "bc", default=True, extendto=dim) basis = np.array([[1.0, 0.0], [cosdg(120), sindg(120)]]) sites = [ {"siteid": 0, "type": 0, "coord": [0.0, 0.0]}, {"siteid": 1, "type": 0, "coord": [0.5, 0.0]}, {"siteid": 1, "type": 0, "coord": [0.5, 0.5]}, ] bonds = [ { "bondid": 0, "type": 0, "source": {"siteid": 0}, "target": {"siteid": 1, "offset": [0, 0]}, }, { "bondid": 1, "type": 0, "source": {"siteid": 0}, "target": {"siteid": 2, "offset": [0, 0]}, }, { "bondid": 2, "type": 0, "source": {"siteid": 1}, "target": {"siteid": 2, "offset": [0, 0]}, }, { "bondid": 3, "type": 0, "source": {"siteid": 1}, "target": {"siteid": 0, "offset": [1, 0]}, }, { "bondid": 4, "type": 0, "source": {"siteid": 2}, "target": {"siteid": 1, "offset": [0, 1]}, }, { "bondid": 5, "type": 0, "source": {"siteid": 2}, "target": {"siteid": 0, "offset": [1, 1]}, }, ] parameter = {"name": "kagome", "dim": dim, "L": L, "bc": bc, "basis": basis} unitcell = {"sites": sites, "bonds": bonds} return {"parameter": parameter, "unitcell": unitcell}
def dist_from_m31(*args, **kwargs): """ Formerly computeDist Computes distance from M31 center in kpc, designed for stars within the disk Default PA of M31 away from vertical is 50 degrees, computed through trial and error off of a Galex image Required arguments: - ra: right ascension - dec: declination Optional arguments - tanplane: are your input positions already in the tangent plane - tilt: tilt of M31 - i: inclination of M31 """ if len(args) == 2: ra, dec = args else: print 'Proper syntax is "computeDist(ra, dec, tanplane= T/F)' return tanplane = kwargs.get("tanplane", False) tilt = kwargs.get("tilt", 50) i = kwargs.get("i", 74) d31 = 41.269 r31 = 10.68 * cosdg(d31) if tanplane: # If RA is already in the tangent plane x = (ra - r31) * 13.67 else: # If it isn't ra_new = ra * cosdg(d31) x = (ra_new - r31) * 13.67 y = (dec - d31) * 13.67 xr = x * cosdg(tilt) + y * sindg(tilt) yr = -x * sindg(tilt) + y * cosdg(tilt) r = np.sqrt(xr ** 2 + yr ** 2) alpha = np.arctan2(yr, xr * cosdg(i)) * 180.0 / np.pi dist = r / (np.sqrt(cosdg(alpha) ** 2 + (sindg(alpha) * cosdg(i)) ** 2)) return dist
fun1 = special.kelvin(15) print(fun1) fun2 = special.xlogy(2, 10) print(fun2) fun3 = special.exp10(50) print(fun3) fun4 = special.sindg(60) print(fun4) fun5 = special.cosdg(60) print(fun5) print('---------------------') def var1(x): return x**3 fun6 = integrate.quad(var1, 0, 6) print(fun6) def var2(y, x): return x * y**4
import pdb import pyfits import matplotlib import CM_MASTER import show_galex import numpy as np import matplotlib.pyplot as py from scipy.special import cosdg cmbase = CM_MASTER.CM_Master() dr = 0.24*cosdg(cmbase.d31) dd = 0.24 rbins = np.arange(min(cmbase.ra*cosdg(cmbase.d31)),max(cmbase.ra*cosdg(cmbase.d31)),dr) dbins = np.arange(min(cmbase.dec), max(cmbase.dec),dd) rabins = (rbins - cmbase.r31*cosdg(cmbase.d31))*-13.67 decbins = (dbins - cmbase.d31)*13.67 allRA = (cmbase.ra-cmbase.r31)*cosdg(cmbase.d31)*-13.67 allDEC = (cmbase.dec - cmbase.d31)*13.67 agbra = allRA[cmbase.params['EVSTAGE'] == 'AGB'] agbdec = allDEC[cmbase.params['EVSTAGE'] == 'AGB'] cra = allRA[cmbase.c]
import scipy from scipy import cluster from scipy import special from scipy import integrate a = special.exp10(2) print(a) b = special.exp2(2) print(b) c = special.sindg(90) print(c) print(special.cosdg(0)) print(scipy.integrate.quad(lambda x: special.exp10(x), 0, 1))
from scipy import special # for computing 10^x a = special.exp10(2) print(a) # for computing 2^x a = special.exp2(3) print(a) # sin function s = special.sindg(90) print(s) # cos function c = special.cosdg(90) print(c)
# v_guess = term1/term2 hdu = pyfits.open('/Users/khamren/M31_Research/splash_data/subMasterSPLASH_zerr.fits') data = hdu[1].data cstars = data[(data.CID == 'c') & (data.FIELDTYPE == 'disk') & (data.RA != '00:00:00')] agb = data[((data.EVSTAGE == 'AGB') | (data.EVSTAGE == 'agb')) & (data.FIELDTYPE == 'disk') & (data.RA != '00:00:00')] agb_noc = data[((data.EVSTAGE == 'AGB') | (data.EVSTAGE == 'agb')) & (data.FIELDTYPE == 'disk') & (data.RA != '00:00:00') & (data.CID != 'c')] #cvel = (cstars.Z*c) - (cstars.ABAND*c) - helcorr(keck_long,keck_lat,keck_alt,cra, cdec,cstars.MJD)[0] cra = np.array([hms2deg(r,d)[0] for r,d in zip(cstars.RA, cstars.DEC)]) cra2 = cra*cosdg(d31) cdec = np.array([hms2deg(r,d)[1] for r,d in zip(cstars.RA, cstars.DEC)]) cdist = computeDist(cra, cdec) ara = np.array([hms2deg(r,d)[0] for r,d in zip(agb_noc.RA, agb_noc.DEC)]) ara2 = ara*cosdg(d31) adec = np.array([hms2deg(r,d)[1] for r,d in zip(agb_noc.RA, agb_noc.DEC)]) ara_all = np.array([hms2deg(r,d)[0] for r,d in zip(agb.RA, agb.DEC)]) ara2_all = ara_all*cosdg(d31) adec_all = np.array([hms2deg(r,d)[1] for r,d in zip(agb.RA, agb.DEC)]) cvel = np.array([((z*c) - (aband*c) - helcorr(keck_long,keck_lat,keck_alt,r,d, mjd)[0]) for z, aband, r, d, mjd in zip(cstars.Z, cstars.ABAND, cra, cdec, cstars.MJD)]) avel = np.array([((z*c) - (aband*c) - helcorr(keck_long, keck_lat,keck_alt, r,d, mjd)[0]) for z, aband, r, d, mjd in zip(agb_noc.Z, agb_noc.ABAND, ara, adec, agb_noc.MJD)]) averr = agb_noc.Z_ERR*c
# Python Full Course - Learn Python in 12 Hours | Python Tutorial For Beginners | Edureka # This lesson looks at some of the special mathematical functions in SciPy such as # exponential and trigonometric functions. # We need to import special the function # from the scipy library from scipy import special # Exponential Functions # Calculates 10 to the power of 2 a = special.exp10(2) # Outputs 10 squared print("10 squared =", a) b = special.exp2(3) print("2 cubed =", b) # Trigonometric Functions # Gets the sine value of an angle in degrees c = special.sindg(90) print("The sine value of 90 degrees is:", c) # Gets the cosine value of of an angle in degrees d = special.cosdg(0) print("The cosine value of 0 degrees is:", d)
def rotate(input_arr, angle, axes=(1, 0), reshape=True, output=None, order=1, mode='constant', cval=0.0, prefilter=False, output_chunks=None, output_shape=None): """ Rotate an array using Dask. Chunkwise processing is performed using dask_image.ndinterp.affine_transform The array is rotated in the plane defined by the two axes given by the `axes` parameter using spline interpolation of the requested order. Parameters ---------- %(input)s angle : float The rotation angle in degrees. axes : tuple of 2 ints, optional The two axes that define the plane of rotation. Default is the first two axes. reshape : bool, optional If `reshape` is true, the output shape is adapted so that the input array is contained completely in the output. Default is True. %(output)s order : int, optional The order of the spline interpolation, default is 3. The order has to be in the range 0-5. %(mode_interp_constant)s %(cval)s %(prefilter)s Returns ------- rotate : ndarray The rotated input. Notes ----- Differences to `ndimage.affine_transformation`: - currently, prefiltering is not supported (affecting the output in case of interpolation `order > 1`) - default order is 1 - modes 'reflect', 'mirror' and 'wrap' are not supported Arguments equal to `ndimage.affine_rotate`, except for `output_chunks`. .. versionadded:: 1.6.0 Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> import dask.array as da >>> fig = plt.figure(figsize=(10, 3)) >>> ax1, ax2, ax3 = fig.subplots(1, 3) >>> img = da.from_array(misc.ascent(),chunks=(64,64)) >>> img_45 = dask_image.ndinterp.rotate(img, 45, reshape=False) >>> full_img_45 = dask_image.ndinterp.rotate(img, 45, reshape=True) >>> ax1.imshow(img, cmap='gray') >>> ax1.set_axis_off() >>> ax2.imshow(img_45, cmap='gray') >>> ax2.set_axis_off() >>> ax3.imshow(full_img_45, cmap='gray') >>> ax3.set_axis_off() >>> fig.set_tight_layout(True) >>> plt.show() >>> print(img.shape) (512, 512) >>> print(img_45.shape) (512, 512) >>> print(full_img_45.shape) (724, 724) """ # input_arr = input#np.asarray(input) if not type(input_arr) == da.core.Array: input_arr = da.from_array(input_arr) if output_shape is None: output_shape = input_arr.shape ndim = input_arr.ndim if reshape & (output_shape != None): warnings.warn( 'Both reshaping desired and output_shape provided.' 'Will use the explicit output_shape.', UserWarning) if ndim < 2: raise ValueError('input array should be at least 2D') axes = list(axes) if len(axes) != 2: raise ValueError('axes should contain exactly two values') if not all([float(ax).is_integer() for ax in axes]): raise ValueError('axes should contain only integer values') if axes[0] < 0: axes[0] += ndim if axes[1] < 0: axes[1] += ndim if axes[0] < 0 or axes[1] < 0 or axes[0] >= ndim or axes[1] >= ndim: raise ValueError('invalid rotation plane specified') axes.sort() c, s = special.cosdg(angle), special.sindg(angle) rot_matrix = np.array([[c, s], [-s, c]]) img_shape = np.asarray(input_arr.shape) in_plane_shape = img_shape[axes] if reshape: # Compute transformed input bounds iy, ix = in_plane_shape out_bounds = rot_matrix @ [[0, 0, iy, iy], [0, ix, 0, ix]] # Compute the shape of the transformed input plane out_plane_shape = (out_bounds.ptp(axis=1) + 0.5).astype(int) else: out_plane_shape = img_shape[axes] if output_shape is None: output_shape = img_shape output_shape[axes] = out_plane_shape else: out_plane_shape = np.asarray(output_shape)[axes] out_center = rot_matrix @ ((out_plane_shape - 1) / 2) in_center = (in_plane_shape - 1) / 2 offset = in_center - out_center output_shape = tuple(output_shape) if ndim <= 2: output = affine_transform(input_arr, rot_matrix, offset=offset, output_shape=tuple(output_shape), order=order, mode=mode, cval=cval, prefilter=prefilter, output_chunks=output_chunks) elif ndim >= 3: rotmat_nd = np.eye(ndim) offset_nd = np.zeros(ndim) for o_x, idx in enumerate(axes): rotmat_nd[idx, axes[0]] = rot_matrix[o_x, 0] rotmat_nd[idx, axes[1]] = rot_matrix[o_x, 1] offset_nd[idx] = offset[o_x] output = affine_transform(input_arr, rotmat_nd, offset=offset_nd, output_shape=tuple(output_shape), order=order, mode=mode, cval=cval, prefilter=prefilter, output_chunks=output_chunks) return output
def find_hit_position(angle, pos, track_map, dl=1.0): """ This function returns the point at which a beam coming from point pos at angle given by angle variable for the first time crosses a non zero point on the map Timing at Marcin computer: dl = 5.0 -> about max 0.4 ms; It is roughly valid: dl/n -> time*n :param angle: angle (deg) in which the beam is going, e.g the body angle of the car :param pos: point ((x,y) in pixels) where the beam starts, e.g. position of the car :param track_map: a SPECIAL map which is non-zero in sand region and zero on track. Use map_lidar for it. :param dl: determines the precision of the collision point determination - the algorithm moves along the beam and checks every dl pixels (does not need to be integer) if it left the track :return the point on the track boundary which the beam first hits ((x,y) in pixels) (e.g. which the car would hit if it would go on a straight line) """ (h, w) = track_map.shape found = False # x = meters2pixels(pos[0]) # y = meters2pixels(pos[1]) x = pos[0] y = pos[1] # Depending on direction we take y = ax+b or x = ay+b if (45.0 < angle < 135.0) or (225.0 < angle < 315.0): # x = ay+b dy = dl * sindg(angle) # dy = dl a = cotdg(angle) b = x - a * y while 0 < x < w and 0 < y < h: if track_map[int(y), int(x)] > 0: found = True break else: y = y + dy x = a * y + b else: # dx = dl dx = dl * cosdg(angle) a = tandg(angle) b = y - a * x while 0 < x < w and 0 < y < h: if track_map[int(y), int(x)] > 0: found = True break else: x = x + dx y = a * x + b if found: hit_pos = (x, y) else: hit_pos = None return hit_pos
#oh_out = np.column_stack((ra_matched, dec_matched, dist_oh, obj_oh, obj_eoh)) #np.savetxt('HII_OH_all.txt', oh_out, fmt = ('%10.8f','%10.8f','%6.4f','%4.3f','%4.3f')) #pdb.set_trace() #pOH = np.polyfit(dist_oh, obj_oh[inds],1) #-----------Get SPLASH data----------------------------- cmbase = CM_MASTER.CM_Master() #dr = 0.24*cosdg(cmbase.d31) #dd = 0.24 #rbins = np.arange(min(cmbase.ra*cosdg(cmbase.d31)),max(cmbase.ra*cosdg(cmbase.d31)),dr) #dbins = np.arange(min(cmbase.dec), max(cmbase.dec),dd) radbins = np.arange(3, 25, 5) cra = cmbase.ra[cmbase.c]*cosdg(cmbase.d31) cdec = cmbase.dec[cmbase.c] cdist = computeDist(cra, cdec, tanplane = True) hC, bins = np.histogram(cdist, bins = radbins) hC *= 1.0 raB95 = cmbase.ra[cmbase.brewer]*cosdg(cmbase.d31) decB95 = cmbase.dec[cmbase.brewer] distB95 = computeDist(raB95, decB95, tanplane = True) hB95, bins = np.histogram(distB95, bins = radbins) cmB95 = hC/hB95 cmB95e = cmB95*np.sqrt((hC+hB95)/(hC*hB95))
def matchDUSTiNGS(type, ra, dec, masks): if type == 'dsph': table = np.genfromtxt('/Users/khamren/M31_Research/splash_data/DUSTiNGS/dsph_goodcat.tsv', delimiter=';', dtype=str, filling_values='9999') elif type == 'de': table = np.genfromtxt('/Users/khamren/M31_Research/splash_data/DUSTiNGS/ngc_goodcat.tsv', delimiter=';', dtype=str, filling_values='9999') else: raise AttributeError('Input type should be dsph or de') dust_fields = np.array([convert_to_mask(m) for m in table[:,0]]) dust_ra = np.array([hms2deg(':'.join(r.strip().split()),':'.join(d.strip().split()))[0] for r,d in zip(table[:,1],table[:,2])]) dust_dec = np.array([hms2deg(':'.join(r.strip().split()),':'.join(d.strip().split()))[1] for r,d in zip(table[:,1],table[:,2])]) n = len(ra) m36 = np.empty(n) em36 = np.empty(n) m45 = np.empty(n) em45 = np.empty(n) splash_fields = np.array([re.split('_',m)[0].lower() for m in masks]) for i,r,d,m in zip(range(n),ra, dec,splash_fields): if m == 'd7bi': m = 'd7' dist = np.array([3600*np.sqrt(((r-rv)*cosdg(d))**2 + (d-dv)**2) for rv, dv in zip(dust_ra[dust_fields == m], dust_dec[dust_fields == m])]) try: if (len(dist) == 0) or (min(dist) > 0.5): m36[i] = np.nan em36[i] = np.nan m45[i] = np.nan em45[i] = np.nan else: j = np.argwhere(dist == min(dist))[0][0] try: m36[i] =(table[j,3].astype(float)) em36[i] =(table[j,4].astype(float)) m45[i] =(table[j,9].astype(float)) em45[i] =(table[j,10].astype(float)) except: try: m36[i] =(table[j,5].astype(float)) em36[i] =(table[j,6].astype(float)) m45[i] =(table[j,11].astype(float)) em45[i] =(table[j,12].astype(float)) except: try: m36[i] =(table[j,7].astype(float)) em36[i] =(table[j,8].astype(float)) m45[i] =(table[j,13].astype(float)) em45[i] =(table[j,14].astype(float)) except: m36[i] = np.nan em36[i] = np.nan m45[i] = np.nan em45[i] = np.nan except: pdb.set_trace() return np.array(m36), np.array(em36), np.array(m45), np.array(em45)
def rotate(input, angle, axes=(1, 0), reshape=True, output=None, order=3, mode='constant', cval=0.0, prefilter=True): """ Rotate an array. The array is rotated in the plane defined by the two axes given by the `axes` parameter using spline interpolation of the requested order. Parameters ---------- %(input)s angle : float The rotation angle in degrees. axes : tuple of 2 ints, optional The two axes that define the plane of rotation. Default is the first two axes. reshape : bool, optional If `reshape` is true, the output shape is adapted so that the input array is contained completely in the output. Default is True. %(output)s order : int, optional The order of the spline interpolation, default is 3. The order has to be in the range 0-5. %(mode_interp_constant)s %(cval)s %(prefilter)s Returns ------- rotate : ndarray The rotated input. Notes ----- For complex-valued `input`, this function rotates the real and imaginary components independently. .. versionadded:: 1.6.0 Complex-valued support added. Examples -------- >>> from scipy import ndimage, misc >>> import matplotlib.pyplot as plt >>> fig = plt.figure(figsize=(10, 3)) >>> ax1, ax2, ax3 = fig.subplots(1, 3) >>> img = misc.ascent() >>> img_45 = ndimage.rotate(img, 45, reshape=False) >>> full_img_45 = ndimage.rotate(img, 45, reshape=True) >>> ax1.imshow(img, cmap='gray') >>> ax1.set_axis_off() >>> ax2.imshow(img_45, cmap='gray') >>> ax2.set_axis_off() >>> ax3.imshow(full_img_45, cmap='gray') >>> ax3.set_axis_off() >>> fig.set_tight_layout(True) >>> plt.show() >>> print(img.shape) (512, 512) >>> print(img_45.shape) (512, 512) >>> print(full_img_45.shape) (724, 724) """ input_arr = numpy.asarray(input) ndim = input_arr.ndim if ndim < 2: raise ValueError('input array should be at least 2D') axes = list(axes) if len(axes) != 2: raise ValueError('axes should contain exactly two values') if not all([float(ax).is_integer() for ax in axes]): raise ValueError('axes should contain only integer values') if axes[0] < 0: axes[0] += ndim if axes[1] < 0: axes[1] += ndim if axes[0] < 0 or axes[1] < 0 or axes[0] >= ndim or axes[1] >= ndim: raise ValueError('invalid rotation plane specified') axes.sort() c, s = special.cosdg(angle), special.sindg(angle) rot_matrix = numpy.array([[c, s], [-s, c]]) img_shape = numpy.asarray(input_arr.shape) in_plane_shape = img_shape[axes] if reshape: # Compute transformed input bounds iy, ix = in_plane_shape out_bounds = rot_matrix @ [[0, 0, iy, iy], [0, ix, 0, ix]] # Compute the shape of the transformed input plane out_plane_shape = (out_bounds.ptp(axis=1) + 0.5).astype(int) else: out_plane_shape = img_shape[axes] out_center = rot_matrix @ ((out_plane_shape - 1) / 2) in_center = (in_plane_shape - 1) / 2 offset = in_center - out_center output_shape = img_shape output_shape[axes] = out_plane_shape output_shape = tuple(output_shape) complex_output = numpy.iscomplexobj(input_arr) output = _ni_support._get_output(output, input_arr, shape=output_shape, complex_output=complex_output) if ndim <= 2: affine_transform(input_arr, rot_matrix, offset, output_shape, output, order, mode, cval, prefilter) else: # If ndim > 2, the rotation is applied over all the planes # parallel to axes planes_coord = itertools.product( *[[slice(None)] if ax in axes else range(img_shape[ax]) for ax in range(ndim)]) out_plane_shape = tuple(out_plane_shape) for coordinates in planes_coord: ia = input_arr[coordinates] oa = output[coordinates] affine_transform(ia, rot_matrix, offset, out_plane_shape, oa, order, mode, cval, prefilter) return output
import scipy as sp from scipy import special fun1 = special.kelvin(15) print(fun1) fun2 = special.xlogy(2, 10) print(fun2) fun3 = special.exp10(50) print(fun3) fun4 = special.sindg(30) print(fun4) fun5 = special.cosdg(90) print(fun5)