idx int64 0 63k | question stringlengths 61 4.03k | target stringlengths 6 1.23k |
|---|---|---|
58,700 | def ekopw ( fname ) : fname = stypes . stringToCharP ( fname ) handle = ctypes . c_int ( ) libspice . ekopw_c ( fname , ctypes . byref ( handle ) ) return handle . value | Open an existing E - kernel file for writing . |
58,701 | def ekpsel ( query , msglen , tablen , collen ) : query = stypes . stringToCharP ( query ) msglen = ctypes . c_int ( msglen ) tablen = ctypes . c_int ( tablen ) collen = ctypes . c_int ( collen ) n = ctypes . c_int ( ) xbegs = stypes . emptyIntVector ( _SPICE_EK_MAXQSEL ) xends = stypes . emptyIntVector ( _SPICE_EK_MAXQSEL ) xtypes = stypes . emptyIntVector ( _SPICE_EK_MAXQSEL ) xclass = stypes . emptyIntVector ( _SPICE_EK_MAXQSEL ) tabs = stypes . emptyCharArray ( yLen = _SPICE_EK_MAXQSEL , xLen = tablen ) cols = stypes . emptyCharArray ( yLen = _SPICE_EK_MAXQSEL , xLen = collen ) error = ctypes . c_int ( ) errmsg = stypes . stringToCharP ( msglen ) libspice . ekpsel_c ( query , msglen , tablen , collen , ctypes . byref ( n ) , xbegs , xends , xtypes , xclass , ctypes . byref ( tabs ) , ctypes . byref ( cols ) , ctypes . byref ( error ) , errmsg ) return ( n . value , stypes . cVectorToPython ( xbegs ) [ : n . value ] , stypes . cVectorToPython ( xends ) [ : n . value ] , stypes . cVectorToPython ( xtypes ) [ : n . value ] , stypes . cVectorToPython ( xclass ) [ : n . value ] , stypes . cVectorToPython ( tabs ) [ : n . value ] , stypes . cVectorToPython ( cols ) [ : n . value ] , error . value , stypes . toPythonString ( errmsg ) ) | Parse the SELECT clause of an EK query returning full particulars concerning each selected item . |
58,702 | def ekrcec ( handle , segno , recno , column , lenout , nelts = _SPICE_EK_EKRCEX_ROOM_DEFAULT ) : handle = ctypes . c_int ( handle ) segno = ctypes . c_int ( segno ) recno = ctypes . c_int ( recno ) column = stypes . stringToCharP ( column ) lenout = ctypes . c_int ( lenout ) nvals = ctypes . c_int ( ) cvals = stypes . emptyCharArray ( yLen = nelts , xLen = lenout ) isnull = ctypes . c_int ( ) libspice . ekrcec_c ( handle , segno , recno , column , lenout , ctypes . byref ( nvals ) , ctypes . byref ( cvals ) , ctypes . byref ( isnull ) ) assert failed ( ) or ( nvals . value <= nelts ) return nvals . value , stypes . cVectorToPython ( cvals ) [ : nvals . value ] , bool ( isnull . value ) | Read data from a character column in a specified EK record . |
58,703 | def ekrced ( handle , segno , recno , column , nelts = _SPICE_EK_EKRCEX_ROOM_DEFAULT ) : handle = ctypes . c_int ( handle ) segno = ctypes . c_int ( segno ) recno = ctypes . c_int ( recno ) column = stypes . stringToCharP ( column ) nvals = ctypes . c_int ( 0 ) dvals = stypes . emptyDoubleVector ( nelts ) isnull = ctypes . c_int ( ) libspice . ekrced_c ( handle , segno , recno , column , ctypes . byref ( nvals ) , dvals , ctypes . byref ( isnull ) ) assert failed ( ) or ( nvals . value <= nelts ) return nvals . value , stypes . cVectorToPython ( dvals ) [ : nvals . value ] , bool ( isnull . value ) | Read data from a double precision column in a specified EK record . |
58,704 | def ekrcei ( handle , segno , recno , column , nelts = _SPICE_EK_EKRCEX_ROOM_DEFAULT ) : handle = ctypes . c_int ( handle ) segno = ctypes . c_int ( segno ) recno = ctypes . c_int ( recno ) column = stypes . stringToCharP ( column ) nvals = ctypes . c_int ( ) ivals = stypes . emptyIntVector ( nelts ) isnull = ctypes . c_int ( ) libspice . ekrcei_c ( handle , segno , recno , column , ctypes . byref ( nvals ) , ivals , ctypes . byref ( isnull ) ) assert failed ( ) or ( nvals . value <= nelts ) return nvals . value , stypes . cVectorToPython ( ivals ) [ : nvals . value ] , bool ( isnull . value ) | Read data from an integer column in a specified EK record . |
58,705 | def ekssum ( handle , segno ) : handle = ctypes . c_int ( handle ) segno = ctypes . c_int ( segno ) segsum = stypes . SpiceEKSegSum ( ) libspice . ekssum_c ( handle , segno , ctypes . byref ( segsum ) ) return segsum | Return summary information for a specified segment in a specified EK . |
58,706 | def ektnam ( n , lenout = _default_len_out ) : n = ctypes . c_int ( n ) lenout = ctypes . c_int ( lenout ) table = stypes . stringToCharP ( lenout ) libspice . ektnam_c ( n , lenout , table ) return stypes . toPythonString ( table ) | Return the name of a specified loaded table . |
58,707 | def ekucec ( handle , segno , recno , column , nvals , cvals , isnull ) : handle = ctypes . c_int ( handle ) segno = ctypes . c_int ( segno ) recno = ctypes . c_int ( recno ) column = stypes . stringToCharP ( column ) nvals = ctypes . c_int ( nvals ) vallen = ctypes . c_int ( len ( max ( cvals , key = len ) ) + 1 ) cvals = stypes . listToCharArrayPtr ( cvals , xLen = vallen ) isnull = ctypes . c_int ( isnull ) libspice . ekucec_c ( handle , segno , recno , column , nvals , vallen , cvals , isnull ) | Update a character column entry in a specified EK record . |
58,708 | def ekuced ( handle , segno , recno , column , nvals , dvals , isnull ) : handle = ctypes . c_int ( handle ) segno = ctypes . c_int ( segno ) recno = ctypes . c_int ( recno ) column = stypes . stringToCharP ( column ) nvals = ctypes . c_int ( nvals ) dvals = stypes . toDoubleVector ( dvals ) isnull = ctypes . c_int ( isnull ) libspice . ekaced_c ( handle , segno , recno , column , nvals , dvals , isnull ) | Update a double precision column entry in a specified EK record . |
58,709 | def ekucei ( handle , segno , recno , column , nvals , ivals , isnull ) : handle = ctypes . c_int ( handle ) segno = ctypes . c_int ( segno ) recno = ctypes . c_int ( recno ) column = stypes . stringToCharP ( column ) nvals = ctypes . c_int ( nvals ) ivals = stypes . toIntVector ( ivals ) isnull = ctypes . c_int ( isnull ) libspice . ekucei_c ( handle , segno , recno , column , nvals , ivals , isnull ) | Update an integer column entry in a specified EK record . |
58,710 | def el2cgv ( ellipse ) : assert ( isinstance ( ellipse , stypes . Ellipse ) ) center = stypes . emptyDoubleVector ( 3 ) smajor = stypes . emptyDoubleVector ( 3 ) sminor = stypes . emptyDoubleVector ( 3 ) libspice . el2cgv_c ( ctypes . byref ( ellipse ) , center , smajor , sminor ) return stypes . cVectorToPython ( center ) , stypes . cVectorToPython ( smajor ) , stypes . cVectorToPython ( sminor ) | Convert an ellipse to a center vector and two generating vectors . The selected generating vectors are semi - axes of the ellipse . |
58,711 | def elemc ( item , inset ) : assert isinstance ( inset , stypes . SpiceCell ) item = stypes . stringToCharP ( item ) return bool ( libspice . elemc_c ( item , ctypes . byref ( inset ) ) ) | Determine whether an item is an element of a character set . |
58,712 | def elemd ( item , inset ) : assert isinstance ( inset , stypes . SpiceCell ) assert inset . dtype == 1 item = ctypes . c_double ( item ) return bool ( libspice . elemd_c ( item , ctypes . byref ( inset ) ) ) | Determine whether an item is an element of a double precision set . |
58,713 | def elemi ( item , inset ) : assert isinstance ( inset , stypes . SpiceCell ) assert inset . dtype == 2 item = ctypes . c_int ( item ) return bool ( libspice . elemi_c ( item , ctypes . byref ( inset ) ) ) | Determine whether an item is an element of an integer set . |
58,714 | def eqstr ( a , b ) : return bool ( libspice . eqstr_c ( stypes . stringToCharP ( a ) , stypes . stringToCharP ( b ) ) ) | Determine whether two strings are equivalent . |
58,715 | def erract ( op , lenout , action = None ) : if action is None : action = "" lenout = ctypes . c_int ( lenout ) op = stypes . stringToCharP ( op ) action = ctypes . create_string_buffer ( str . encode ( action ) , lenout . value ) actionptr = ctypes . c_char_p ( ctypes . addressof ( action ) ) libspice . erract_c ( op , lenout , actionptr ) return stypes . toPythonString ( actionptr ) | Retrieve or set the default error action . spiceypy sets the default error action to report on init . |
58,716 | def errch ( marker , string ) : marker = stypes . stringToCharP ( marker ) string = stypes . stringToCharP ( string ) libspice . errch_c ( marker , string ) | Substitute a character string for the first occurrence of a marker in the current long error message . |
58,717 | def errdev ( op , lenout , device ) : lenout = ctypes . c_int ( lenout ) op = stypes . stringToCharP ( op ) device = ctypes . create_string_buffer ( str . encode ( device ) , lenout . value ) deviceptr = ctypes . c_char_p ( ctypes . addressof ( device ) ) libspice . errdev_c ( op , lenout , deviceptr ) return stypes . toPythonString ( deviceptr ) | Retrieve or set the name of the current output device for error messages . |
58,718 | def errdp ( marker , number ) : marker = stypes . stringToCharP ( marker ) number = ctypes . c_double ( number ) libspice . errdp_c ( marker , number ) | Substitute a double precision number for the first occurrence of a marker found in the current long error message . |
58,719 | def errint ( marker , number ) : marker = stypes . stringToCharP ( marker ) number = ctypes . c_int ( number ) libspice . errint_c ( marker , number ) | Substitute an integer for the first occurrence of a marker found in the current long error message . |
58,720 | def errprt ( op , lenout , inlist ) : lenout = ctypes . c_int ( lenout ) op = stypes . stringToCharP ( op ) inlist = ctypes . create_string_buffer ( str . encode ( inlist ) , lenout . value ) inlistptr = ctypes . c_char_p ( ctypes . addressof ( inlist ) ) libspice . errdev_c ( op , lenout , inlistptr ) return stypes . toPythonString ( inlistptr ) | Retrieve or set the list of error message items to be output when an error is detected . |
58,721 | def esrchc ( value , array ) : value = stypes . stringToCharP ( value ) ndim = ctypes . c_int ( len ( array ) ) lenvals = ctypes . c_int ( len ( max ( array , key = len ) ) + 1 ) array = stypes . listToCharArray ( array , xLen = lenvals , yLen = ndim ) return libspice . esrchc_c ( value , ndim , lenvals , array ) | Search for a given value within a character string array . Return the index of the first equivalent array entry or - 1 if no equivalent element is found . |
58,722 | def et2lst ( et , body , lon , typein , timlen = _default_len_out , ampmlen = _default_len_out ) : et = ctypes . c_double ( et ) body = ctypes . c_int ( body ) lon = ctypes . c_double ( lon ) typein = stypes . stringToCharP ( typein ) timlen = ctypes . c_int ( timlen ) ampmlen = ctypes . c_int ( ampmlen ) hr = ctypes . c_int ( ) mn = ctypes . c_int ( ) sc = ctypes . c_int ( ) time = stypes . stringToCharP ( timlen ) ampm = stypes . stringToCharP ( ampmlen ) libspice . et2lst_c ( et , body , lon , typein , timlen , ampmlen , ctypes . byref ( hr ) , ctypes . byref ( mn ) , ctypes . byref ( sc ) , time , ampm ) return hr . value , mn . value , sc . value , stypes . toPythonString ( time ) , stypes . toPythonString ( ampm ) | Given an ephemeris epoch compute the local solar time for an object on the surface of a body at a specified longitude . |
58,723 | def et2utc ( et , formatStr , prec , lenout = _default_len_out ) : et = ctypes . c_double ( et ) prec = ctypes . c_int ( prec ) lenout = ctypes . c_int ( lenout ) formatStr = stypes . stringToCharP ( formatStr ) utcstr = stypes . stringToCharP ( lenout ) libspice . et2utc_c ( et , formatStr , prec , lenout , utcstr ) return stypes . toPythonString ( utcstr ) | Convert an input time from ephemeris seconds past J2000 to Calendar Day - of - Year or Julian Date format UTC . |
58,724 | def etcal ( et , lenout = _default_len_out ) : lenout = ctypes . c_int ( lenout ) string = stypes . stringToCharP ( lenout ) if hasattr ( et , "__iter__" ) : strings = [ ] for t in et : libspice . etcal_c ( t , lenout , string ) checkForSpiceError ( None ) strings . append ( stypes . toPythonString ( string ) ) return strings else : et = ctypes . c_double ( et ) libspice . etcal_c ( et , lenout , string ) return stypes . toPythonString ( string ) | Convert from an ephemeris epoch measured in seconds past the epoch of J2000 to a calendar string format using a formal calendar free of leapseconds . |
58,725 | def eul2m ( angle3 , angle2 , angle1 , axis3 , axis2 , axis1 ) : angle3 = ctypes . c_double ( angle3 ) angle2 = ctypes . c_double ( angle2 ) angle1 = ctypes . c_double ( angle1 ) axis3 = ctypes . c_int ( axis3 ) axis2 = ctypes . c_int ( axis2 ) axis1 = ctypes . c_int ( axis1 ) r = stypes . emptyDoubleMatrix ( ) libspice . eul2m_c ( angle3 , angle2 , angle1 , axis3 , axis2 , axis1 , r ) return stypes . cMatrixToNumpy ( r ) | Construct a rotation matrix from a set of Euler angles . |
58,726 | def eul2xf ( eulang , axisa , axisb , axisc ) : assert len ( eulang ) is 6 eulang = stypes . toDoubleVector ( eulang ) axisa = ctypes . c_int ( axisa ) axisb = ctypes . c_int ( axisb ) axisc = ctypes . c_int ( axisc ) xform = stypes . emptyDoubleMatrix ( x = 6 , y = 6 ) libspice . eul2xf_c ( eulang , axisa , axisb , axisc , xform ) return stypes . cMatrixToNumpy ( xform ) | This routine computes a state transformation from an Euler angle factorization of a rotation and the derivatives of those Euler angles . |
58,727 | def exists ( fname ) : fname = stypes . stringToCharP ( fname ) return bool ( libspice . exists_c ( fname ) ) | Determine whether a file exists . |
58,728 | def expool ( name ) : name = stypes . stringToCharP ( name ) found = ctypes . c_int ( ) libspice . expool_c ( name , ctypes . byref ( found ) ) return bool ( found . value ) | Confirm the existence of a kernel variable in the kernel pool . |
58,729 | def frmnam ( frcode , lenout = _default_len_out ) : frcode = ctypes . c_int ( frcode ) lenout = ctypes . c_int ( lenout ) frname = stypes . stringToCharP ( lenout ) libspice . frmnam_c ( frcode , lenout , frname ) return stypes . toPythonString ( frname ) | Retrieve the name of a reference frame associated with a SPICE ID code . |
58,730 | def furnsh ( path ) : if isinstance ( path , list ) : for p in path : libspice . furnsh_c ( stypes . stringToCharP ( p ) ) else : path = stypes . stringToCharP ( path ) libspice . furnsh_c ( path ) | Load one or more SPICE kernels into a program . |
58,731 | def gcpool ( name , start , room , lenout = _default_len_out ) : name = stypes . stringToCharP ( name ) start = ctypes . c_int ( start ) room = ctypes . c_int ( room ) lenout = ctypes . c_int ( lenout ) n = ctypes . c_int ( ) cvals = stypes . emptyCharArray ( lenout , room ) found = ctypes . c_int ( ) libspice . gcpool_c ( name , start , room , lenout , ctypes . byref ( n ) , ctypes . byref ( cvals ) , ctypes . byref ( found ) ) return [ stypes . toPythonString ( x . value ) for x in cvals [ 0 : n . value ] ] , bool ( found . value ) | Return the character value of a kernel variable from the kernel pool . |
58,732 | def gdpool ( name , start , room ) : name = stypes . stringToCharP ( name ) start = ctypes . c_int ( start ) values = stypes . emptyDoubleVector ( room ) room = ctypes . c_int ( room ) n = ctypes . c_int ( ) found = ctypes . c_int ( ) libspice . gdpool_c ( name , start , room , ctypes . byref ( n ) , ctypes . cast ( values , ctypes . POINTER ( ctypes . c_double ) ) , ctypes . byref ( found ) ) return stypes . cVectorToPython ( values ) [ 0 : n . value ] , bool ( found . value ) | Return the d . p . value of a kernel variable from the kernel pool . |
58,733 | def georec ( lon , lat , alt , re , f ) : lon = ctypes . c_double ( lon ) lat = ctypes . c_double ( lat ) alt = ctypes . c_double ( alt ) re = ctypes . c_double ( re ) f = ctypes . c_double ( f ) rectan = stypes . emptyDoubleVector ( 3 ) libspice . georec_c ( lon , lat , alt , re , f , rectan ) return stypes . cVectorToPython ( rectan ) | Convert geodetic coordinates to rectangular coordinates . |
58,734 | def getelm ( frstyr , lineln , lines ) : frstyr = ctypes . c_int ( frstyr ) lineln = ctypes . c_int ( lineln ) lines = stypes . listToCharArrayPtr ( lines , xLen = lineln , yLen = 2 ) epoch = ctypes . c_double ( ) elems = stypes . emptyDoubleVector ( 10 ) libspice . getelm_c ( frstyr , lineln , lines , ctypes . byref ( epoch ) , elems ) return epoch . value , stypes . cVectorToPython ( elems ) | Given a the lines of a two - line element set parse the lines and return the elements in units suitable for use in SPICE software . |
58,735 | def getfat ( file ) : file = stypes . stringToCharP ( file ) arclen = ctypes . c_int ( 4 ) typlen = ctypes . c_int ( 4 ) arch = stypes . stringToCharP ( arclen ) rettype = stypes . stringToCharP ( typlen ) libspice . getfat_c ( file , arclen , typlen , arch , rettype ) return stypes . toPythonString ( arch ) , stypes . toPythonString ( rettype ) | Determine the file architecture and file type of most SPICE kernel files . |
58,736 | def getmsg ( option , lenout = _default_len_out ) : option = stypes . stringToCharP ( option ) lenout = ctypes . c_int ( lenout ) msg = stypes . stringToCharP ( lenout ) libspice . getmsg_c ( option , lenout , msg ) return stypes . toPythonString ( msg ) | Retrieve the current short error message the explanation of the short error message or the long error message . |
58,737 | def gfdist ( target , abcorr , obsrvr , relate , refval , adjust , step , nintvls , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) target = stypes . stringToCharP ( target ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) relate = stypes . stringToCharP ( relate ) refval = ctypes . c_double ( refval ) adjust = ctypes . c_double ( adjust ) step = ctypes . c_double ( step ) nintvls = ctypes . c_int ( nintvls ) libspice . gfdist_c ( target , abcorr , obsrvr , relate , refval , adjust , step , nintvls , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Return the time window over which a specified constraint on observer - target distance is met . |
58,738 | def gfevnt ( udstep , udrefn , gquant , qnpars , lenvals , qpnams , qcpars , qdpars , qipars , qlpars , op , refval , tol , adjust , rpt , udrepi , udrepu , udrepf , nintvls , bail , udbail , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) gquant = stypes . stringToCharP ( gquant ) qnpars = ctypes . c_int ( qnpars ) lenvals = ctypes . c_int ( lenvals ) qpnams = stypes . listToCharArrayPtr ( qpnams , xLen = lenvals , yLen = qnpars ) qcpars = stypes . listToCharArrayPtr ( qcpars , xLen = lenvals , yLen = qnpars ) qdpars = stypes . toDoubleVector ( qdpars ) qipars = stypes . toIntVector ( qipars ) qlpars = stypes . toIntVector ( qlpars ) op = stypes . stringToCharP ( op ) refval = ctypes . c_double ( refval ) tol = ctypes . c_double ( tol ) adjust = ctypes . c_double ( adjust ) rpt = ctypes . c_int ( rpt ) nintvls = ctypes . c_int ( nintvls ) bail = ctypes . c_int ( bail ) libspice . gfevnt_c ( udstep , udrefn , gquant , qnpars , lenvals , qpnams , qcpars , qdpars , qipars , qlpars , op , refval , tol , adjust , rpt , udrepi , udrepu , udrepf , nintvls , bail , udbail , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Determine time intervals when a specified geometric quantity satisfies a specified mathematical condition . |
58,739 | def gfilum ( method , angtyp , target , illumn , fixref , abcorr , obsrvr , spoint , relate , refval , adjust , step , nintvls , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) method = stypes . stringToCharP ( method ) angtyp = stypes . stringToCharP ( angtyp ) target = stypes . stringToCharP ( target ) illumn = stypes . stringToCharP ( illumn ) fixref = stypes . stringToCharP ( fixref ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) spoint = stypes . toDoubleVector ( spoint ) relate = stypes . stringToCharP ( relate ) refval = ctypes . c_double ( refval ) adjust = ctypes . c_double ( adjust ) step = ctypes . c_double ( step ) nintvls = ctypes . c_int ( nintvls ) libspice . gfilum_c ( method , angtyp , target , illumn , fixref , abcorr , obsrvr , spoint , relate , refval , adjust , step , nintvls , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Return the time window over which a specified constraint on the observed phase solar incidence or emission angle at a specifed target body surface point is met . |
58,740 | def gfocce ( occtyp , front , fshape , fframe , back , bshape , bframe , abcorr , obsrvr , tol , udstep , udrefn , rpt , udrepi , udrepu , udrepf , bail , udbail , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) occtyp = stypes . stringToCharP ( occtyp ) front = stypes . stringToCharP ( front ) fshape = stypes . stringToCharP ( fshape ) fframe = stypes . stringToCharP ( fframe ) back = stypes . stringToCharP ( back ) bshape = stypes . stringToCharP ( bshape ) bframe = stypes . stringToCharP ( bframe ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) tol = ctypes . c_double ( tol ) rpt = ctypes . c_int ( rpt ) bail = ctypes . c_int ( bail ) libspice . gfocce_c ( occtyp , front , fshape , fframe , back , bshape , bframe , abcorr , obsrvr , tol , udstep , udrefn , rpt , udrepi , udrepu , udrepf , bail , udbail , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Determine time intervals when an observer sees one target occulted by another . Report progress and handle interrupts if so commanded . |
58,741 | def gfoclt ( occtyp , front , fshape , fframe , back , bshape , bframe , abcorr , obsrvr , step , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) occtyp = stypes . stringToCharP ( occtyp ) front = stypes . stringToCharP ( front ) fshape = stypes . stringToCharP ( fshape ) fframe = stypes . stringToCharP ( fframe ) back = stypes . stringToCharP ( back ) bshape = stypes . stringToCharP ( bshape ) bframe = stypes . stringToCharP ( bframe ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) step = ctypes . c_double ( step ) libspice . gfoclt_c ( occtyp , front , fshape , fframe , back , bshape , bframe , abcorr , obsrvr , step , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Determine time intervals when an observer sees one target occulted by or in transit across another . |
58,742 | def gfpa ( target , illmin , abcorr , obsrvr , relate , refval , adjust , step , nintvals , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) target = stypes . stringToCharP ( target ) illmin = stypes . stringToCharP ( illmin ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) relate = stypes . stringToCharP ( relate ) refval = ctypes . c_double ( refval ) adjust = ctypes . c_double ( adjust ) step = ctypes . c_double ( step ) nintvals = ctypes . c_int ( nintvals ) libspice . gfpa_c ( target , illmin , abcorr , obsrvr , relate , refval , adjust , step , nintvals , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Determine time intervals for which a specified constraint on the phase angle between an illumination source a target and observer body centers is met . |
58,743 | def gfposc ( target , inframe , abcorr , obsrvr , crdsys , coord , relate , refval , adjust , step , nintvals , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) target = stypes . stringToCharP ( target ) inframe = stypes . stringToCharP ( inframe ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) crdsys = stypes . stringToCharP ( crdsys ) coord = stypes . stringToCharP ( coord ) relate = stypes . stringToCharP ( relate ) refval = ctypes . c_double ( refval ) adjust = ctypes . c_double ( adjust ) step = ctypes . c_double ( step ) nintvals = ctypes . c_int ( nintvals ) libspice . gfposc_c ( target , inframe , abcorr , obsrvr , crdsys , coord , relate , refval , adjust , step , nintvals , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Determine time intervals for which a coordinate of an observer - target position vector satisfies a numerical constraint . |
58,744 | def gfrefn ( t1 , t2 , s1 , s2 ) : t1 = ctypes . c_double ( t1 ) t2 = ctypes . c_double ( t2 ) s1 = ctypes . c_int ( s1 ) s2 = ctypes . c_int ( s2 ) t = ctypes . c_double ( ) libspice . gfrefn_c ( t1 , t2 , s1 , s2 , ctypes . byref ( t ) ) return t . value | For those times when we can t do better we use a bisection method to find the next time at which to test for state change . |
58,745 | def gfrepi ( window , begmss , endmss ) : begmss = stypes . stringToCharP ( begmss ) endmss = stypes . stringToCharP ( endmss ) if not isinstance ( window , ctypes . POINTER ( stypes . SpiceCell ) ) : assert isinstance ( window , stypes . SpiceCell ) assert window . is_double ( ) window = ctypes . byref ( window ) libspice . gfrepi_c ( window , begmss , endmss ) | This entry point initializes a search progress report . |
58,746 | def gfrepu ( ivbeg , ivend , time ) : ivbeg = ctypes . c_double ( ivbeg ) ivend = ctypes . c_double ( ivend ) time = ctypes . c_double ( time ) libspice . gfrepu_c ( ivbeg , ivend , time ) | This function tells the progress reporting system how far a search has progressed . |
58,747 | def gfsep ( targ1 , shape1 , inframe1 , targ2 , shape2 , inframe2 , abcorr , obsrvr , relate , refval , adjust , step , nintvals , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) targ1 = stypes . stringToCharP ( targ1 ) shape1 = stypes . stringToCharP ( shape1 ) inframe1 = stypes . stringToCharP ( inframe1 ) targ2 = stypes . stringToCharP ( targ2 ) shape2 = stypes . stringToCharP ( shape2 ) inframe2 = stypes . stringToCharP ( inframe2 ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) relate = stypes . stringToCharP ( relate ) refval = ctypes . c_double ( refval ) adjust = ctypes . c_double ( adjust ) step = ctypes . c_double ( step ) nintvals = ctypes . c_int ( nintvals ) libspice . gfsep_c ( targ1 , shape1 , inframe1 , targ2 , shape2 , inframe2 , abcorr , obsrvr , relate , refval , adjust , step , nintvals , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Determine time intervals when the angular separation between the position vectors of two target bodies relative to an observer satisfies a numerical relationship . |
58,748 | def gfsntc ( target , fixref , method , abcorr , obsrvr , dref , dvec , crdsys , coord , relate , refval , adjust , step , nintvals , cnfine , result = None ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) target = stypes . stringToCharP ( target ) fixref = stypes . stringToCharP ( fixref ) method = stypes . stringToCharP ( method ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) dref = stypes . stringToCharP ( dref ) dvec = stypes . toDoubleVector ( dvec ) crdsys = stypes . stringToCharP ( crdsys ) coord = stypes . stringToCharP ( coord ) relate = stypes . stringToCharP ( relate ) refval = ctypes . c_double ( refval ) adjust = ctypes . c_double ( adjust ) step = ctypes . c_double ( step ) nintvals = ctypes . c_int ( nintvals ) libspice . gfsntc_c ( target , fixref , method , abcorr , obsrvr , dref , dvec , crdsys , coord , relate , refval , adjust , step , nintvals , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Determine time intervals for which a coordinate of an surface intercept position vector satisfies a numerical constraint . |
58,749 | def gfsubc ( target , fixref , method , abcorr , obsrvr , crdsys , coord , relate , refval , adjust , step , nintvals , cnfine , result ) : assert isinstance ( cnfine , stypes . SpiceCell ) assert cnfine . is_double ( ) if result is None : result = stypes . SPICEDOUBLE_CELL ( 2000 ) else : assert isinstance ( result , stypes . SpiceCell ) assert result . is_double ( ) target = stypes . stringToCharP ( target ) fixref = stypes . stringToCharP ( fixref ) method = stypes . stringToCharP ( method ) abcorr = stypes . stringToCharP ( abcorr ) obsrvr = stypes . stringToCharP ( obsrvr ) crdsys = stypes . stringToCharP ( crdsys ) coord = stypes . stringToCharP ( coord ) relate = stypes . stringToCharP ( relate ) refval = ctypes . c_double ( refval ) adjust = ctypes . c_double ( adjust ) step = ctypes . c_double ( step ) nintvals = ctypes . c_int ( nintvals ) libspice . gfsubc_c ( target , fixref , method , abcorr , obsrvr , crdsys , coord , relate , refval , adjust , step , nintvals , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Determine time intervals for which a coordinate of an subpoint position vector satisfies a numerical constraint . |
58,750 | def gfudb ( udfuns , udfunb , step , cnfine , result ) : step = ctypes . c_double ( step ) libspice . gfudb_c ( udfuns , udfunb , step , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) | Perform a GF search on a user defined boolean quantity . |
58,751 | def gfuds ( udfuns , udqdec , relate , refval , adjust , step , nintvls , cnfine , result ) : relate = stypes . stringToCharP ( relate ) refval = ctypes . c_double ( refval ) adjust = ctypes . c_double ( adjust ) step = ctypes . c_double ( step ) nintvls = ctypes . c_int ( nintvls ) libspice . gfuds_c ( udfuns , udqdec , relate , refval , adjust , step , nintvls , ctypes . byref ( cnfine ) , ctypes . byref ( result ) ) return result | Perform a GF search on a user defined scalar quantity . |
58,752 | def gipool ( name , start , room ) : name = stypes . stringToCharP ( name ) start = ctypes . c_int ( start ) ivals = stypes . emptyIntVector ( room ) room = ctypes . c_int ( room ) n = ctypes . c_int ( ) found = ctypes . c_int ( ) libspice . gipool_c ( name , start , room , ctypes . byref ( n ) , ivals , ctypes . byref ( found ) ) return stypes . cVectorToPython ( ivals ) [ 0 : n . value ] , bool ( found . value ) | Return the integer value of a kernel variable from the kernel pool . |
58,753 | def gnpool ( name , start , room , lenout = _default_len_out ) : name = stypes . stringToCharP ( name ) start = ctypes . c_int ( start ) kvars = stypes . emptyCharArray ( yLen = room , xLen = lenout ) room = ctypes . c_int ( room ) lenout = ctypes . c_int ( lenout ) n = ctypes . c_int ( ) found = ctypes . c_int ( ) libspice . gnpool_c ( name , start , room , lenout , ctypes . byref ( n ) , kvars , ctypes . byref ( found ) ) return stypes . cVectorToPython ( kvars ) [ 0 : n . value ] , bool ( found . value ) | Return names of kernel variables matching a specified template . |
58,754 | def hx2dp ( string ) : string = stypes . stringToCharP ( string ) lenout = ctypes . c_int ( 80 ) errmsg = stypes . stringToCharP ( lenout ) number = ctypes . c_double ( ) error = ctypes . c_int ( ) libspice . hx2dp_c ( string , lenout , ctypes . byref ( number ) , ctypes . byref ( error ) , errmsg ) if not error . value : return number . value else : return stypes . toPythonString ( errmsg ) | Convert a string representing a double precision number in a base 16 scientific notation into its equivalent double precision number . |
58,755 | def ident ( ) : matrix = stypes . emptyDoubleMatrix ( ) libspice . ident_c ( matrix ) return stypes . cMatrixToNumpy ( matrix ) | This routine returns the 3x3 identity matrix . |
58,756 | def inedpl ( a , b , c , plane ) : assert ( isinstance ( plane , stypes . Plane ) ) ellipse = stypes . Ellipse ( ) a = ctypes . c_double ( a ) b = ctypes . c_double ( b ) c = ctypes . c_double ( c ) found = ctypes . c_int ( ) libspice . inedpl_c ( a , b , c , ctypes . byref ( plane ) , ctypes . byref ( ellipse ) , ctypes . byref ( found ) ) return ellipse , bool ( found . value ) | Find the intersection of a triaxial ellipsoid and a plane . |
58,757 | def inelpl ( ellips , plane ) : assert ( isinstance ( plane , stypes . Plane ) ) assert ( isinstance ( ellips , stypes . Ellipse ) ) nxpts = ctypes . c_int ( ) xpt1 = stypes . emptyDoubleVector ( 3 ) xpt2 = stypes . emptyDoubleVector ( 3 ) libspice . inelpl_c ( ctypes . byref ( ellips ) , ctypes . byref ( plane ) , ctypes . byref ( nxpts ) , xpt1 , xpt2 ) return nxpts . value , stypes . cVectorToPython ( xpt1 ) , stypes . cVectorToPython ( xpt2 ) | Find the intersection of an ellipse and a plane . |
58,758 | def inrypl ( vertex , direct , plane ) : assert ( isinstance ( plane , stypes . Plane ) ) vertex = stypes . toDoubleVector ( vertex ) direct = stypes . toDoubleVector ( direct ) nxpts = ctypes . c_int ( ) xpt = stypes . emptyDoubleVector ( 3 ) libspice . inrypl_c ( vertex , direct , ctypes . byref ( plane ) , ctypes . byref ( nxpts ) , xpt ) return nxpts . value , stypes . cVectorToPython ( xpt ) | Find the intersection of a ray and a plane . |
58,759 | def insrtc ( item , inset ) : assert isinstance ( inset , stypes . SpiceCell ) if isinstance ( item , list ) : for c in item : libspice . insrtc_c ( stypes . stringToCharP ( c ) , ctypes . byref ( inset ) ) else : item = stypes . stringToCharP ( item ) libspice . insrtc_c ( item , ctypes . byref ( inset ) ) | Insert an item into a character set . |
58,760 | def insrtd ( item , inset ) : assert isinstance ( inset , stypes . SpiceCell ) if hasattr ( item , "__iter__" ) : for d in item : libspice . insrtd_c ( ctypes . c_double ( d ) , ctypes . byref ( inset ) ) else : item = ctypes . c_double ( item ) libspice . insrtd_c ( item , ctypes . byref ( inset ) ) | Insert an item into a double precision set . |
58,761 | def insrti ( item , inset ) : assert isinstance ( inset , stypes . SpiceCell ) if hasattr ( item , "__iter__" ) : for i in item : libspice . insrti_c ( ctypes . c_int ( i ) , ctypes . byref ( inset ) ) else : item = ctypes . c_int ( item ) libspice . insrti_c ( item , ctypes . byref ( inset ) ) | Insert an item into an integer set . |
58,762 | def inter ( a , b ) : assert isinstance ( a , stypes . SpiceCell ) assert isinstance ( b , stypes . SpiceCell ) assert a . dtype == b . dtype if a . dtype is 0 : c = stypes . SPICECHAR_CELL ( max ( a . size , b . size ) , max ( a . length , b . length ) ) elif a . dtype is 1 : c = stypes . SPICEDOUBLE_CELL ( max ( a . size , b . size ) ) elif a . dtype is 2 : c = stypes . SPICEINT_CELL ( max ( a . size , b . size ) ) else : raise NotImplementedError libspice . inter_c ( ctypes . byref ( a ) , ctypes . byref ( b ) , ctypes . byref ( c ) ) return c | Intersect two sets of any data type to form a third set . |
58,763 | def invert ( m ) : m = stypes . toDoubleMatrix ( m ) mout = stypes . emptyDoubleMatrix ( ) libspice . invert_c ( m , mout ) return stypes . cMatrixToNumpy ( mout ) | Generate the inverse of a 3x3 matrix . |
58,764 | def invort ( m ) : m = stypes . toDoubleMatrix ( m ) mout = stypes . emptyDoubleMatrix ( ) libspice . invort_c ( m , mout ) return stypes . cMatrixToNumpy ( mout ) | Given a matrix construct the matrix whose rows are the columns of the first divided by the length squared of the the corresponding columns of the input matrix . |
58,765 | def isordv ( array , n ) : array = stypes . toIntVector ( array ) n = ctypes . c_int ( n ) return bool ( libspice . isordv_c ( array , n ) ) | Determine whether an array of n items contains the integers 0 through n - 1 . |
58,766 | def isrchc ( value , ndim , lenvals , array ) : value = stypes . stringToCharP ( value ) array = stypes . listToCharArrayPtr ( array , xLen = lenvals , yLen = ndim ) ndim = ctypes . c_int ( ndim ) lenvals = ctypes . c_int ( lenvals ) return libspice . isrchc_c ( value , ndim , lenvals , array ) | Search for a given value within a character string array . Return the index of the first matching array entry or - 1 if the key value was not found . |
58,767 | def isrchd ( value , ndim , array ) : value = ctypes . c_double ( value ) ndim = ctypes . c_int ( ndim ) array = stypes . toDoubleVector ( array ) return libspice . isrchd_c ( value , ndim , array ) | Search for a given value within a double precision array . Return the index of the first matching array entry or - 1 if the key value was not found . |
58,768 | def isrchi ( value , ndim , array ) : value = ctypes . c_int ( value ) ndim = ctypes . c_int ( ndim ) array = stypes . toIntVector ( array ) return libspice . isrchi_c ( value , ndim , array ) | Search for a given value within an integer array . Return the index of the first matching array entry or - 1 if the key value was not found . |
58,769 | def isrot ( m , ntol , dtol ) : m = stypes . toDoubleMatrix ( m ) ntol = ctypes . c_double ( ntol ) dtol = ctypes . c_double ( dtol ) return bool ( libspice . isrot_c ( m , ntol , dtol ) ) | Indicate whether a 3x3 matrix is a rotation matrix . |
58,770 | def iswhsp ( string ) : string = stypes . stringToCharP ( string ) return bool ( libspice . iswhsp_c ( string ) ) | Return a boolean value indicating whether a string contains only white space characters . |
58,771 | def kdata ( which , kind , fillen = _default_len_out , typlen = _default_len_out , srclen = _default_len_out ) : which = ctypes . c_int ( which ) kind = stypes . stringToCharP ( kind ) fillen = ctypes . c_int ( fillen ) typlen = ctypes . c_int ( typlen ) srclen = ctypes . c_int ( srclen ) file = stypes . stringToCharP ( fillen ) filtyp = stypes . stringToCharP ( typlen ) source = stypes . stringToCharP ( srclen ) handle = ctypes . c_int ( ) found = ctypes . c_int ( ) libspice . kdata_c ( which , kind , fillen , typlen , srclen , file , filtyp , source , ctypes . byref ( handle ) , ctypes . byref ( found ) ) return stypes . toPythonString ( file ) , stypes . toPythonString ( filtyp ) , stypes . toPythonString ( source ) , handle . value , bool ( found . value ) | Return data for the nth kernel that is among a list of specified kernel types . |
58,772 | def kinfo ( file , typlen = _default_len_out , srclen = _default_len_out ) : typlen = ctypes . c_int ( typlen ) srclen = ctypes . c_int ( srclen ) file = stypes . stringToCharP ( file ) filtyp = stypes . stringToCharP ( " " * typlen . value ) source = stypes . stringToCharP ( " " * srclen . value ) handle = ctypes . c_int ( ) found = ctypes . c_int ( ) libspice . kinfo_c ( file , typlen , srclen , filtyp , source , ctypes . byref ( handle ) , ctypes . byref ( found ) ) return stypes . toPythonString ( filtyp ) , stypes . toPythonString ( source ) , handle . value , bool ( found . value ) | Return information about a loaded kernel specified by name . |
58,773 | def kplfrm ( frmcls , outCell = None ) : if not outCell : outCell = stypes . SPICEINT_CELL ( 1000 ) frmcls = ctypes . c_int ( frmcls ) libspice . kplfrm_c ( frmcls , ctypes . byref ( outCell ) ) return outCell | Return a SPICE set containing the frame IDs of all reference frames of a given class having specifications in the kernel pool . |
58,774 | def ktotal ( kind ) : kind = stypes . stringToCharP ( kind ) count = ctypes . c_int ( ) libspice . ktotal_c ( kind , ctypes . byref ( count ) ) return count . value | Return the current number of kernels that have been loaded via the KEEPER interface that are of a specified type . |
58,775 | def kxtrct ( keywd , terms , nterms , instring , termlen = _default_len_out , stringlen = _default_len_out , substrlen = _default_len_out ) : assert nterms <= len ( terms ) keywd = stypes . stringToCharP ( keywd ) terms = stypes . listToCharArrayPtr ( [ s [ : termlen - 1 ] for s in terms [ : nterms ] ] , xLen = termlen , yLen = nterms ) instring = stypes . stringToCharP ( instring [ : stringlen - 1 ] , inlen = stringlen ) substr = stypes . stringToCharP ( substrlen ) termlen = ctypes . c_int ( termlen ) nterms = ctypes . c_int ( nterms ) stringlen = ctypes . c_int ( stringlen ) substrlen = ctypes . c_int ( substrlen ) found = ctypes . c_int ( ) libspice . kxtrct_c ( keywd , termlen , terms , nterms , stringlen , substrlen , instring , ctypes . byref ( found ) , substr ) return stypes . toPythonString ( instring ) , stypes . toPythonString ( substr ) , bool ( found . value ) | Locate a keyword in a string and extract the substring from the beginning of the first word following the keyword to the beginning of the first subsequent recognized terminator of a list . |
58,776 | def latcyl ( radius , lon , lat ) : radius = ctypes . c_double ( radius ) lon = ctypes . c_double ( lon ) lat = ctypes . c_double ( lat ) r = ctypes . c_double ( ) lonc = ctypes . c_double ( ) z = ctypes . c_double ( ) libspice . latcyl_c ( radius , lon , lat , ctypes . byref ( r ) , ctypes . byref ( lonc ) , ctypes . byref ( z ) ) return r . value , lonc . value , z . value | Convert from latitudinal coordinates to cylindrical coordinates . |
58,777 | def latrec ( radius , longitude , latitude ) : radius = ctypes . c_double ( radius ) longitude = ctypes . c_double ( longitude ) latitude = ctypes . c_double ( latitude ) rectan = stypes . emptyDoubleVector ( 3 ) libspice . latrec_c ( radius , longitude , latitude , rectan ) return stypes . cVectorToPython ( rectan ) | Convert from latitudinal coordinates to rectangular coordinates . |
58,778 | def latsph ( radius , lon , lat ) : radius = ctypes . c_double ( radius ) lon = ctypes . c_double ( lon ) lat = ctypes . c_double ( lat ) rho = ctypes . c_double ( ) colat = ctypes . c_double ( ) lons = ctypes . c_double ( ) libspice . latsph_c ( radius , lon , lat , ctypes . byref ( rho ) , ctypes . byref ( colat ) , ctypes . byref ( lons ) ) return rho . value , colat . value , lons . value | Convert from latitudinal coordinates to spherical coordinates . |
58,779 | def lcase ( instr , lenout = _default_len_out ) : instr = stypes . stringToCharP ( instr ) lenout = ctypes . c_int ( lenout ) outstr = stypes . stringToCharP ( lenout ) libspice . lcase_c ( instr , lenout , outstr ) return stypes . toPythonString ( outstr ) | Convert the characters in a string to lowercase . |
58,780 | def lmpool ( cvals ) : lenvals = ctypes . c_int ( len ( max ( cvals , key = len ) ) + 1 ) n = ctypes . c_int ( len ( cvals ) ) cvals = stypes . listToCharArrayPtr ( cvals , xLen = lenvals , yLen = n ) libspice . lmpool_c ( cvals , lenvals , n ) | Load the variables contained in an internal buffer into the kernel pool . |
58,781 | def lparse ( inlist , delim , nmax ) : delim = stypes . stringToCharP ( delim ) lenout = ctypes . c_int ( len ( inlist ) ) inlist = stypes . stringToCharP ( inlist ) nmax = ctypes . c_int ( nmax ) items = stypes . emptyCharArray ( lenout , nmax ) n = ctypes . c_int ( ) libspice . lparse_c ( inlist , delim , nmax , lenout , ctypes . byref ( n ) , ctypes . byref ( items ) ) return [ stypes . toPythonString ( x . value ) for x in items [ 0 : n . value ] ] | Parse a list of items delimited by a single character . |
58,782 | def lparsm ( inlist , delims , nmax , lenout = None ) : if lenout is None : lenout = ctypes . c_int ( len ( inlist ) + 1 ) else : lenout = ctypes . c_int ( lenout ) inlist = stypes . stringToCharP ( inlist ) delims = stypes . stringToCharP ( delims ) items = stypes . emptyCharArray ( lenout . value , nmax ) nmax = ctypes . c_int ( nmax ) n = ctypes . c_int ( ) libspice . lparsm_c ( inlist , delims , nmax , lenout , ctypes . byref ( n ) , items ) return [ stypes . toPythonString ( x . value ) for x in items ] [ 0 : n . value ] | Parse a list of items separated by multiple delimiters . |
58,783 | def lparss ( inlist , delims , NMAX = 20 , LENGTH = 50 ) : inlist = stypes . stringToCharP ( inlist ) delims = stypes . stringToCharP ( delims ) returnSet = stypes . SPICECHAR_CELL ( NMAX , LENGTH ) libspice . lparss_c ( inlist , delims , ctypes . byref ( returnSet ) ) return returnSet | Parse a list of items separated by multiple delimiters placing the resulting items into a set . |
58,784 | def lspcn ( body , et , abcorr ) : body = stypes . stringToCharP ( body ) et = ctypes . c_double ( et ) abcorr = stypes . stringToCharP ( abcorr ) return libspice . lspcn_c ( body , et , abcorr ) | Compute L_s the planetocentric longitude of the sun as seen from a specified body . |
58,785 | def lstlec ( string , n , lenvals , array ) : string = stypes . stringToCharP ( string ) array = stypes . listToCharArrayPtr ( array , xLen = lenvals , yLen = n ) n = ctypes . c_int ( n ) lenvals = ctypes . c_int ( lenvals ) return libspice . lstlec_c ( string , n , lenvals , array ) | Given a character string and an ordered array of character strings find the index of the largest array element less than or equal to the given string . |
58,786 | def lstled ( x , n , array ) : array = stypes . toDoubleVector ( array ) x = ctypes . c_double ( x ) n = ctypes . c_int ( n ) return libspice . lstled_c ( x , n , array ) | Given a number x and an array of non - decreasing floats find the index of the largest array element less than or equal to x . |
58,787 | def lstlei ( x , n , array ) : array = stypes . toIntVector ( array ) x = ctypes . c_int ( x ) n = ctypes . c_int ( n ) return libspice . lstlei_c ( x , n , array ) | Given a number x and an array of non - decreasing ints find the index of the largest array element less than or equal to x . |
58,788 | def lstltc ( string , n , lenvals , array ) : string = stypes . stringToCharP ( string ) array = stypes . listToCharArrayPtr ( array , xLen = lenvals , yLen = n ) n = ctypes . c_int ( n ) lenvals = ctypes . c_int ( lenvals ) return libspice . lstltc_c ( string , n , lenvals , array ) | Given a character string and an ordered array of character strings find the index of the largest array element less than the given string . |
58,789 | def lstltd ( x , n , array ) : array = stypes . toDoubleVector ( array ) x = ctypes . c_double ( x ) n = ctypes . c_int ( n ) return libspice . lstltd_c ( x , n , array ) | Given a number x and an array of non - decreasing floats find the index of the largest array element less than x . |
58,790 | def lstlti ( x , n , array ) : array = stypes . toIntVector ( array ) x = ctypes . c_int ( x ) n = ctypes . c_int ( n ) return libspice . lstlti_c ( x , n , array ) | Given a number x and an array of non - decreasing int find the index of the largest array element less than x . |
58,791 | def lx4dec ( string , first ) : string = stypes . stringToCharP ( string ) first = ctypes . c_int ( first ) last = ctypes . c_int ( ) nchar = ctypes . c_int ( ) libspice . lx4dec_c ( string , first , ctypes . byref ( last ) , ctypes . byref ( nchar ) ) return last . value , nchar . value | Scan a string from a specified starting position for the end of a decimal number . |
58,792 | def lx4num ( string , first ) : string = stypes . stringToCharP ( string ) first = ctypes . c_int ( first ) last = ctypes . c_int ( ) nchar = ctypes . c_int ( ) libspice . lx4num_c ( string , first , ctypes . byref ( last ) , ctypes . byref ( nchar ) ) return last . value , nchar . value | Scan a string from a specified starting position for the end of a number . |
58,793 | def lx4sgn ( string , first ) : string = stypes . stringToCharP ( string ) first = ctypes . c_int ( first ) last = ctypes . c_int ( ) nchar = ctypes . c_int ( ) libspice . lx4sgn_c ( string , first , ctypes . byref ( last ) , ctypes . byref ( nchar ) ) return last . value , nchar . value | Scan a string from a specified starting position for the end of a signed integer . |
58,794 | def lx4uns ( string , first ) : string = stypes . stringToCharP ( string ) first = ctypes . c_int ( first ) last = ctypes . c_int ( ) nchar = ctypes . c_int ( ) libspice . lx4uns_c ( string , first , ctypes . byref ( last ) , ctypes . byref ( nchar ) ) return last . value , nchar . value | Scan a string from a specified starting position for the end of an unsigned integer . |
58,795 | def m2eul ( r , axis3 , axis2 , axis1 ) : r = stypes . toDoubleMatrix ( r ) axis3 = ctypes . c_int ( axis3 ) axis2 = ctypes . c_int ( axis2 ) axis1 = ctypes . c_int ( axis1 ) angle3 = ctypes . c_double ( ) angle2 = ctypes . c_double ( ) angle1 = ctypes . c_double ( ) libspice . m2eul_c ( r , axis3 , axis2 , axis1 , ctypes . byref ( angle3 ) , ctypes . byref ( angle2 ) , ctypes . byref ( angle1 ) ) return angle3 . value , angle2 . value , angle1 . value | Factor a rotation matrix as a product of three rotations about specified coordinate axes . |
58,796 | def m2q ( r ) : r = stypes . toDoubleMatrix ( r ) q = stypes . emptyDoubleVector ( 4 ) libspice . m2q_c ( r , q ) return stypes . cVectorToPython ( q ) | Find a unit quaternion corresponding to a specified rotation matrix . |
58,797 | def matchi ( string , templ , wstr , wchr ) : string = stypes . stringToCharP ( string ) templ = stypes . stringToCharP ( templ ) wstr = ctypes . c_char ( wstr . encode ( encoding = 'UTF-8' ) ) wchr = ctypes . c_char ( wchr . encode ( encoding = 'UTF-8' ) ) return bool ( libspice . matchi_c ( string , templ , wstr , wchr ) ) | Determine whether a string is matched by a template containing wild cards . The pattern comparison is case - insensitive . |
58,798 | def matchw ( string , templ , wstr , wchr ) : string = stypes . stringToCharP ( string ) templ = stypes . stringToCharP ( templ ) wstr = ctypes . c_char ( wstr . encode ( encoding = 'UTF-8' ) ) wchr = ctypes . c_char ( wchr . encode ( encoding = 'UTF-8' ) ) return bool ( libspice . matchw_c ( string , templ , wstr , wchr ) ) | Determine whether a string is matched by a template containing wild cards . |
58,799 | def mequ ( m1 ) : m1 = stypes . toDoubleMatrix ( m1 ) mout = stypes . emptyDoubleMatrix ( ) libspice . mequ_c ( m1 , mout ) return stypes . cMatrixToNumpy ( mout ) | Set one double precision 3x3 matrix equal to another . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.