Main Page
Index of Icy functions
A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X 

Index typography for arguments

  • name : lower case argument name denotes an input
  • NAME : upper case argument name denotes an output
  • `name` : a string variable
  • name[N] : an N-vector (Nx1); Array[N]
  • name[N,M] : an NxM array; Array[N,M]
  • name[] : a vector of unspecified dimension
  • (NAME) : a scalar cell/set/window output the user must create with cspice_celld or cspice_celli prior to use
  • _name_ : a vectorized non-string variable with dimension (Sx1) where S represents the measure of vectorization; Array[S]
  • _name[N]_ : a vectorized N-vector with dimension (NxS) where S represents the measure of vectorization; Array[N,S]
  • _name[N,M]_ : a vectorized NxM array with dimension (NxMxS) where S represents the measure of vectorization; Array[N,M,S]
  • _`name`_ : a vector of S strings where S represents the measure of vectorization; Array[S]

A
  • APPNDD: CSPICE_APPNDD, _item_, (CELL)
  • APPNDI: CSPICE_APPNDI, _item_, (CELL)
  • AXISAR: CSPICE_AXISAR, axis[3], angle, R[3,3]

B Top
  • B1900: double = CSPICE_B1900()
  • B1950: double = CSPICE_B1950()
  • BADKPV: CSPICE_BADKPV, `caller`, `name`, `comp`, size, divby, `type`
  • BODC2N: CSPICE_BODC2N, code, `NAME`, FOUND
  • BODC2S: CSPICE_BODC2S, code, `NAME`
  • BODDEF: CSPICE_BODDEF, `name`, code
  • BODFND: boolean = CSPICE_BODFND( body, `item` )
  • BODN2C: CSPICE_BODN2C, `name`, CODE, FOUND
  • BODS2C: CSPICE_BODS2C, `name`, CODE, FOUND
  • BODVAR: CSPICE_BODVAR, body, `item`, VALUES[]
  • BODVCD: CSPICE_BODVCD, bodyid, `item`, maxn, VALUES[]
  • BODVRD: CSPICE_BODVRD, `bodynm`, `item`, maxn, VALUES[]
  • BRCKTD: double = CSPICE_BRCKTD( number, end1, end2 )
  • BRCKTI: integer = CSPICE_BRCKTI( number, end1, end2 )

C Top
  • CARD: integer = CSPICE_CARD( (cell) )
  • CCIFRM: CSPICE_CCIFRM, frclss, clssid, FRCODE, `FRNAME`, CENTER, FOUND
  • CELLD: cell = CSPICE_CELLD(size)
  • CELLI: cell = CSPICE_CELLI(size)
  • CGV2EL: CSPICE_CGV2EL, center[3], vec1[3], vec2[3], ELLIPSE
  • CIDFRM: CSPICE_CIDFRM, cent, FRCODE, `FRNAME`, FOUND
  • CKCLS: CSPICE_CKCLS, handle
  • CKCOV: CSPICE_CKCOV, `ck`, idcode, needav, level, tol, timsys, (COVER)
  • CKGP: CSPICE_CKGP, inst, sclkdp, tol, `ref`, CMAT[3,3], CLKOUT, FOUND
  • CKGPAV: CSPICE_CKGPAV, inst, sclkdp, tol, `ref`, CMAT[3,3], AV[3], CLKOUT, FOUND
  • CKLPF: CSPICE_CKLPF, `fname`, HANDLE
  • CKOBJ: CSPICE_CKOBJ, ck, (IDS)
  • CKOPN: CSPICE_CKOPN, `name`, `ifname`, ncomch, HANDLE
  • CKUPF: CSPICE_CKUPF, handle
  • CKW01: CSPICE_CKW01, handle, begtime, endtime, inst, `ref`, avflag, `segid`, sclkdp[N], quats[4,N], avvs[3,N]
  • CKW02: CSPICE_CKW02, handle, begtim, endtim, inst, `ref`, `segid`, start[N], stop[N], quats[4,N], avvs[3,N], rates[N]
  • CKW03: CSPICE_CKW03, handle, begtim, endtim, inst, `ref`, avflag, `segid`, sclkdp[N], quats[4,N], avvs[3,N], starts[M]
  • CLIGHT: double = CSPICE_CLIGHT()
  • CLPOOL: CSPICE_CLPOOL
  • CMPRSS: CSPICE_CMPRSS, `delim`, n, `input`, `OUTPUT`
  • CNMFRM: CSPICE_CNMFRM, `cname`, FRCODE, `FRNAME`, FOUND
  • CONICS: CSPICE_CONICS, _elts[8]_, _et_, _STATE[6]_
  • CONVRT: CSPICE_CONVRT, x, `in`, `out`, Y
  • CYLLAT: CSPICE_CYLLAT, r, lonc, z, RADIUS, LON, LAT
  • CYLREC: CSPICE_CYLREC, _r_, _lonc_, _z_, _RECTAN[3]_
  • CYLSPH: CSPICE_CYLSPH, r, lonc, z, RADIUS, COLAT, LON

D Top
  • DAFAC: CSPICE_DAFAC, handle, length, buffer[]
  • DAFBBS: CSPICE_DAFBBS, handle
  • DAFBFS: CSPICE_DAFBFS, handle
  • DAFCLS: CSPICE_DAFCLS, handle
  • DAFCS: CSPICE_DAFCS, handle
  • DAFDC: CSPICE_DAFDC, handle
  • DAFEC: CSPICE_DAFEC, handle, bufsiz, lenout, N, BUFFER, DONE
  • DAFFNA: CSPICE_DAFFNA, FOUND
  • DAFFPA: CSPICE_DAFFPA, FOUND
  • DAFGDA: CSPICE_DAFGDA, handle, begin, end, DATA[]
  • DAFGN: CSPICE_DAFGN, `NAME`
  • DAFGS: CSPICE_DAFGS, nd, ni, DC[], IC[]
  • DAFOPR: CSPICE_DAFOPR, `fname`, HANDLE
  • DAFOPW: CSPICE_DAFOPW, `fname`, HANDLE
  • DAFRS: CSPICE_DAFRS, nd, ni, dc[], ic[]
  • DAFUS: CSPICE_DAFUS, sum, nd, ni, DC[], IC[]
  • DASCLS: CSPICE_DASCLS, handle
  • DASEC: CSPICE_DASEC, handle, bufsiz, lenout, N, BUFFER, DONE
  • DASOPR: CSPICE_DASOPR, `fname`, HANDLE
  • DCYLDR: CSPICE_DCYLDR, x, y, z, JACOBI[3,3]
  • DELTET: CSPICE_DELTET, _epoch_, `eptype`, _DELTA_
  • DET: double = CSPICE_DET( m1[3,3] )
  • DGEODR: CSPICE_DGEODR, x, y, z, re, f, JACOBI[3,3]
  • DIAGS2: CSPICE_DIAGS2, symmat[2,2], DIAG[2,2], ROTATE[2,2]
  • DIFF: CSPICE_DIFF, a, b, (C)
  • DLABFS: CSPICE_DLABFS, handle, DLADSC[SPICE_DLA_DSCSIZ], FOUND
  • DLAFNS: CSPICE_DLAFNS, handle, dladsc[SPICE_DLA_DSCSIZ], NXTDSC, FOUND
  • DLATDR: CSPICE_DLATDR, x, y, z, JACOBI[3,3]
  • DP2HX: CSPICE_DP2HX, number, `STRING`
  • DPGRDR: CSPICE_DPGRDR, body, x, y, z, re, f, JACOBI[3,3]
  • DPMAX: double = CSPICE_DPMAX()
  • DPMIN: double = CSPICE_DPMIN()
  • DPR: double = CSPICE_DPR()
  • DRDCYL: CSPICE_DRDCYL, r, lon, z, JACOBI[3,3]
  • DRDGEO: CSPICE_DRDGEO, lon, lat, alt, re, f, JACOBI[3,3]
  • DRDLAT: CSPICE_DRDLAT, r, lon, lat, JACOBI[3,3]
  • DRDPGR: CSPICE_DRDPGR, body, lon, lat, alt, re, f, JACOBI[3,3]
  • DRDSPH: CSPICE_DRDSPH, r, colat, lon, JACOBI[3,3]
  • DSKB02: CSPICE_DSKB02, handle, dladsc[SPICE_DLA_DSCSIZ], NV, NP, NVXTOT, VTXBDS[], VOXSIZ, VOXORI[], VGREXT[], CGSCAL, VTXNPL, VOXNPT, VOXNPL
  • DSKCLS: CSPICE_DSKCLS, handle, optimz
  • DSKD02: CSPICE_DSKD02, handle, dladsc[SPICE_DLA_DSCSIZ], item, start, room, VALUES[]
  • DSKGD: CSPICE_DSKGD, handle, DLADSC[SPICE_DLA_DSCSIZ], DSKDSC[SPICE_DSK_DSCSIZ]
  • DSKGTL: CSPICE_DSKGTL, keywrd, DPVAL
  • DSKI02: CSPICE_DSKI02, handle, dladsc[SPICE_DLA_DSCSIZ], item, start, room, VALUES[]
  • DSKMI2: CSPICE_DSKMI2, vrtces[3,N], plates[3,N], finscl, corscl, worksz, voxpsz, voxlsz, makvtl, spaisz, SPAIXD[SPICE_DSK02_SPADSZ], SPAIXI[spaisz]
  • DSKN02: CSPICE_DSKN02, handle, dladsc[SPICE_DLA_DSCSIZ], plid, NORMAL[3]
  • DSKOBJ: CSPICE_DSKOBJ, dsk, (BODIDS)
  • DSKOPN: CSPICE_DSKOPN, `fname`, `ifname`, ncomch, HANDLE
  • DSKP02: CSPICE_DSKP02, handle, dladsc[SPICE_DLA_DSCSIZ], start, room, PLATES[3,N]
  • DSKRB2: CSPICE_DSKRB2, vrtces[3,NV], plates[3,NP], corsys, corpar[SPICE_DSK_NSYPAR], MNCOR3, MXCOR3
  • DSKSRF: CSPICE_DSKSRF, dsk, bodyid, (SRFIDS)
  • DSKSTL: CSPICE_DSKSTL, keywrd, dpval
  • DSKV02: CSPICE_DSKV02, handle, dladsc[SPICE_DLA_DSCSIZ], start, room, VRTCES[3,N]
  • DSKW02: CSPICE_DSKW02, handle, center, surfid, dclass, `frame`, corsys, corpar[SPICE_DSK_NSYPAR], mncor1, mxcor1, mncor2, mxcor2, mncor3, mxcor3, first, last, vrtces[3,NV], plates[3,NP], spaixd[M], spaixi[N]
  • DSKX02: CSPICE_DSKX02, handle, dladsc[SPICE_DLA_DSCSIZ], vertex, raydir, PLID, XPT[3], FOUND
  • DSKXSI: CSPICE_DSKXSI, pri, target, nsurf, srflst[], et, fixref, vertex[3], raydir[3], XPT[3], HANDLE, DLADSC[SPICE_DLA_DSCSIZ], DSKDSC[SPICE_DSK_DSCSIZ], DC[], IC[], FOUND
  • DSKXV: CSPICE_DSKXV, pri, target, nsurf, srflst, et, fixref, vtxarr[3,N], dirarr[3,N], XPTARR[3,N], FNDARR[N]
  • DSKZ02: CSPICE_DSKZ02, handle, dladsc[SPICE_DLA_DSCSIZ], NV, NP
  • DSPHDR: CSPICE_DSPHDR, x, y, z, JACOBI[3,3]
  • DTPOOL: CSPICE_DTPOOL, `name`, FOUND, N, `TYPE`
  • DUCRSS: CSPICE_DUCRSS, s1[6], s2[6], SOUT[6]
  • DVCRSS: CSPICE_DVCRSS, s1[6], s2[6], SOUT[6]
  • DVDOT: double = CSPICE_DVDOT( s1[6], s2[6] )
  • DVHAT: CSPICE_DVHAT, s1[6], SOUT[6]
  • DVNORM: double = CSPICE_DVNORM( state[6] )
  • DVPOOL: CSPICE_DVPOOL, `name`
  • DVSEP: double = CSPICE_DVSEP( s1[6], s2[6] )

E Top
  • EDLIMB: CSPICE_EDLIMB, a, b, c, viewpt[3], LIMB
  • EDTERM: CSPICE_EDTERM, `trmtyp`, `source`, `target`, et, `fixfrm`, `abcorr`, `obsrvr`, npts, TRGEPC, OBSPOS[3], TERMPTS[3,N]
  • EKACEC: CSPICE_EKACEC, handle, segno, recno, `column`, nvals, cvals_len, cvals[], isnull
  • EKACED: CSPICE_EKACED, handle, segno, recno, `column`, nvals, dvals[], isnull
  • EKACEI: CSPICE_EKACEI, handle, segno, recno, `column`, nvals, ivals[], isnull
  • EKACLC: CSPICE_EKACLC, handle, segno, `column`, vallen, cvals[], entszs[], nlflgs[], rcptrs[], (WKINDX[])
  • EKACLD: CSPICE_EKACLD, handle, segno, `column`, dvals[], entszs[], nlflgs[], rcptrs[], (WKINDX[])
  • EKACLI: CSPICE_EKACLI, handle, segno, `column`, ivals[], entszs[], nlflgs[], rcptrs[], (WKINDX[])
  • EKAPPR: CSPICE_EKAPPR, handle, segno, RECNO
  • EKBSEG: CSPICE_EKBSEG, handle, `tabnam`, ncols, cnames, decls, SEGNO
  • EKCCNT: CSPICE_EKCCNT, `table`, CCOUNT
  • EKCII: CSPICE_EKCII, `table`, cindex, `COLUMN`, ATTDSC
  • EKCLS: CSPICE_EKCLS, handle
  • EKDELR: CSPICE_EKDELR, handle, segno, recno
  • EKFFLD: CSPICE_EKFFLD, handle, segno, rcptrs[]
  • EKFIND: CSPICE_EKFIND, `query`, NMROWS, ERROR, `ERRMSG`
  • EKGC: CSPICE_EKGC, selidx, row, elment, lenout, `CDATA`, NULL, FOUND
  • EKGD: CSPICE_EKGD, selidx, row, elment, DDATA, NULL, FOUND
  • EKGI: CSPICE_EKGI, selidx, row, elment, IDATA, NULL, FOUND
  • EKIFLD: CSPICE_EKIFLD, handle, `tabnam`, ncols, nrows, cnames[], decls[], SEGNO, RCPTRS[]
  • EKINSR: CSPICE_EKINSR, handle, segno, recno
  • EKLEF: CSPICE_EKLEF, `fname`, HANDLE
  • EKNELT: integer = CSPICE_EKNELT( selidx, row )
  • EKNSEG: integer = CSPICE_EKNSEG( handle )
  • EKNTAB: CSPICE_EKNTAB, N
  • EKOPN: CSPICE_EKOPN, `fname`, `ifname`, ncomch, HANDLE
  • EKOPR: CSPICE_EKOPR, `fname`, HANDLE
  • EKOPS: CSPICE_EKOPS, HANDLE
  • EKOPW: CSPICE_EKOPW, `fname`, HANDLE
  • EKPSEL: CSPICE_EKPSEL, `query`, N, XBEGS[], XENDS[], XTYPES[], XCLASS[], TABS[], COLS[], ERROR, `ERRMSG`
  • EKRCEC: CSPICE_EKRCEC, handle, segno, recno, `column`, nelts, cvals_len, CVALS[], ISNULL
  • EKRCED: CSPICE_EKRCED, handle, segno, recno, `column`, nelts, DVALS[], ISNULL
  • EKRCEI: CSPICE_EKRCEI, handle, segno, recno, `column`, nelts, IVALS[], ISNULL
  • EKSSUM: CSPICE_EKSSUM, handle, segno, NROWS, NCOLS, `TABNAM`, CNAMES[], CCLASS[], DTYPE[], SIZES[], STRLEN[], INDEXD[], NULLOK[]
  • EKTNAM: CSPICE_EKTNAM, n, `TABLE`
  • EKUCEC: CSPICE_EKUCEC, handle, segno, recno, `column`, nvals, cvals_len, cvals[], isnull
  • EKUCED: CSPICE_EKUCED, handle, segno, recno, `column`, nvals, dvals[], isnull
  • EKUCEI: CSPICE_EKUCEI, handle, segno, recno, `column`, nvals, ivals[], isnull
  • EKUEF: CSPICE_EKUEF, handle
  • EL2CGV: CSPICE_EL2CGV, ellipse, CENTER[3], SMAJOR[3], SMINOR[3]
  • EQNCPV: CSPICE_EQNCPV, et, epoch, eqel[9], rapol, decpol, STATE[6]
  • EQSTR: boolean = CSPICE_EQSTR( `a`, `b` )
  • ET2LST: CSPICE_ET2LST, _et_, body, lon, `type`, _HR_, _MN_, _SC_, _`TIME`_, _`AMPM`_
  • ET2UTC: CSPICE_ET2UTC, _et_, `format`, prec, _`UTCSTR`_
  • ETCAL: CSPICE_ETCAL, _et_, _`STRING`_
  • EUL2M: CSPICE_EUL2M, angle3, angle2, angle1, axis3, axis2, axis1, R[3,3]
  • EUL2XF: CSPICE_EUL2XF, eulang[6], axisa, axisb, axisc, XFORM[6,6]
  • EXISTS: boolean = CSPICE_EXISTS( `name` )
  • EXPOOL: CSPICE_EXPOOL, `name`, FOUND

F Top
  • FOVRAY: CSPICE_FOVRAY, `instrument`, _raydir[3]_, `ray_frame`, `abcorr`, `observer`, _et_, _VISIBLE_
  • FOVTRG: CSPICE_FOVTRG, `instrument`, `target`, `target_shape`, `target_frame`, `abcorr`, `observer`, _et_, _VISIBLE_
  • FRAME: CSPICE_FRAME, (X[3]), (Y[3]), (Z[3])
  • FRINFO: CSPICE_FRINFO, frcode, CENT, CLSS, CLSSID, FOUND
  • FRMNAM: CSPICE_FRMNAM, frcode, `FRNAME`
  • FURNSH: CSPICE_FURNSH, _`file`_

G Top
  • GCPOOL: CSPICE_GCPOOL, `name`, start, room, length, CVALS[], FOUND
  • GDPOOL: CSPICE_GDPOOL, `name`, start, room, VALUES[], FOUND
  • GEOREC: CSPICE_GEOREC, _lon_, _lat_, _alt_, re, f, _RECTAN[3]_
  • GETELM: CSPICE_GETELM, frstyr, lines, EPOCH, ELEMS[10]
  • GETFAT: CSPICE_GETFAT, `file`, `ARCH`, `TYPE`
  • GETFOV: CSPICE_GETFOV, instid, room, `SHAPE`, `FRAME`, BSIGHT[3], BOUNDS[3,N]
  • GFDIST: CSPICE_GFDIST, `target`, `abcorr`, `obsrvr`, `relate`, refval, adjust, step, nintvls, (cnfine), (RESULT)
  • GFILUM: CSPICE_GFILUM, `method`, `angtyp`, `target`, `illum`, `fixref`, `abcorr`, `obsrvr`, spoint, `relate`, refval, adjust, step, nintvls, (cnfine), (RESULT)
  • GFOCLT: CSPICE_GFOCLT, `occtyp`, `front`, `fshape`, `fframe`, `back`, `bshape`, `bframe`, `abcorr`, `obsrvr`, step, (cnfine), (RESULT)
  • GFPA: CSPICE_GFPA, `target`, `illum`, `abcorr`, `obsrvr`, `relate`, refval, adjust, step, nintvls, (cnfine), (RESULT)
  • GFPOSC: CSPICE_GFPOSC, `target`, `frame`, `abcorr`, `obsrvr`, `crdsys`, `coord`, `relate`, refval, adjust, step, nintvls, (cnfine), (RESULT)
  • GFRFOV: CSPICE_GFRFOV, `inst`, raydir[3], `rframe`, `abcorr`, `obsrvr`, step, (cnfine), (RESULT)
  • GFRR: CSPICE_GFRR, `target`, `abcorr`, `obsrvr`, `relate`, refval, adjust, step, nintvls, (cnfine), (RESULT)
  • GFSEP: CSPICE_GFSEP, `targ1`, `shape1`, `frame1`, `targ2`, `shape2`, `frame2`, `abcorr`, `obsrvr`, `relate`, refval, adjust, step, nintvls, (cnfine), (RESULT)
  • GFSNTC: CSPICE_GFSNTC, `target`, `fixref`, `method`, `abcorr`, `obsrvr`, `dref`, dvec[3], `crdsys`, `coord`, `relate`, refval, adjust, step, nintvls, (cnfine), (RESULT)
  • GFSTOL: CSPICE_GFSTOL, value
  • GFSUBC: CSPICE_GFSUBC, `target`, `fixref`, `method`, `abcorr`, `obsrvr`, `crdsys`, `coord`, `relate`, refval, adjust, step, nintvls, (cnfine), (RESULT)
  • GFTFOV: CSPICE_GFTFOV, `inst`, `target`, `tshape`, `tframe`, `abcorr`, `obsrvr`, step, (cnfine), (RESULT)
  • GIPOOL: CSPICE_GIPOOL, `name`, start, room, IVALS[], FOUND
  • GNPOOL: CSPICE_GNPOOL, `name`, start, room, length, KVARS[], FOUND

H Top
  • HALFPI: double = CSPICE_HALFPI()
  • HX2DP: CSPICE_HX2DP, `string`, NUMBER, ERROR, `ERRMSG`

I Top
  • IDENT: CSPICE_IDENT, MATRIX[3,3]
  • ILLUM: CSPICE_ILLUM, `target`, _et_, `abcorr`, `obsrvr`, _spoint[3]_, _PHASE_, _SOLAR_, _EMISSN_
  • ILLUMF: CSPICE_ILLUMF, `method`, `target`, `ilusrc`, et, `fixref`, `abcorr`, `obsrvr`, spoint[3], TRGEPC, SRFVEC[3], PHASE, INCDNC, EMISSN, VISIBL, LIT
  • ILLUMG: CSPICE_ILLUMG, `method`, `target`, `ilusrc`, et, `fixref`, `abcorr`, `obsrvr`, spoint[3], TRGEPC, SRFVEC[3], PHASE, INCDNC, EMISSN
  • ILLUM_PL02: CSPICE_ILLUM_PL02, handle, dladsc[8], `target`, et, `abcorr`, `obsrvr`, spoint[3], PHASE, SOLAR, EMISSN
  • ILLUM_PLID_PL02: CSPICE_ILLUM_PLID_PL02, handle, dladsc[SPICE_DLA_DSCSIZ], `target`, et, `abcorr`, `obsrvr`, spoint[3], plid, TRGEPC, SRFVEC, PHASE, SOLAR, EMISSN, VISIBLE, LIT
  • ILUMIN: CSPICE_ILUMIN, `method`, `target`, et, `fixref`, `abcorr`, `obsrvr`, spoint[3], TRGEPC, SRFVEC[3], PHASE, SOLAR, EMISSN
  • INEDPL: CSPICE_INEDPL, a, b, c, plane, ELLIPSE, FOUND
  • INELPL: CSPICE_INELPL, ellips, plane, NXPTS, XPT1, XPT2
  • INRYPL: CSPICE_INRYPL, vertex[3], dir[3], plane, NXPTS, XPT[3]
  • INSRTD: CSPICE_INSRTD, _item_, (SET)
  • INSRTI: CSPICE_INSRTI, _item_, (SET)
  • INTER: CSPICE_INTER, a, b, (C)
  • INTMAX: integer = CSPICE_INTMAX()
  • INTMIN: integer = CSPICE_INTMIN()
  • INVERT: CSPICE_INVERT, m1[3,3], M2[3,3]
  • INVORT: CSPICE_INVORT, m1[3,3], M2[3,3]
  • ISROT: boolean = CSPICE_ISROT( m[3,3], ntol, dtol )
  • ISWHSP: boolean = CSPICE_ISWHSP( `STRING` )

J Top
  • J1900: double = CSPICE_J1900()
  • J1950: double = CSPICE_J1950()
  • J2000: double = CSPICE_J2000()
  • J2100: double = CSPICE_J2100()
  • JYEAR: double = CSPICE_JYEAR()

K Top
  • KCLEAR: CSPICE_KCLEAR
  • KDATA: CSPICE_KDATA, which, `kind`, `FILE`, `FILTYP`, `SOURCE`, HANDLE, FOUND
  • KINFO: CSPICE_KINFO, `file`, `FILTYP`, `SOURCE`, HANDLE, FOUND
  • KTOTAL: CSPICE_KTOTAL, `kind`, COUNT

L Top
  • LASTNB: integer = CSPICE_LASTNB( `STRING` )
  • LATCYL: CSPICE_LATCYL, radius, lon, lat, R, LONC, Z
  • LATREC: CSPICE_LATREC, _radius_, _longitude_, _latitude_, _RECTAN[3]_
  • LATSPH: CSPICE_LATSPH, radius, lon, lat, RHO, COLAT, LONS
  • LATSRF: CSPICE_LATSRF, `method`, `target`, et, `fixref`, lonlat[2,N], SRFPTS[3,N]
  • LCASE: CSPICE_LCASE, `in`, `OUT`
  • LDPOOL: CSPICE_LDPOOL, `filename`
  • LIMBPT: CSPICE_LIMBPT, `method`, `target`, et, `fixref`, `abcorr`, corloc, `obsrvr`, refvec, rolstp, ncuts, schstp, soltol, maxn, NPTS[maxn], POINTS[3,maxn], EPOCHS[maxn], TANGTS[3,maxn]
  • LIMB_PL02: CSPICE_LIMB_PL02, handle, dladsc[SPICE_DLA_DSCSIZ], `target`, et, `fixfrm`, `abcorr`, `obsrvr`, npoints, TRGEPC, OBSPOS[], LIMBPTS[3][], PLATEIDS[]
  • LLGRID_PL02: CSPICE_LLGRID_PL02, handle, dladsc[SPICE_DLA_DSCSIZ], npoints, grid, SPOINTS[3][npoints], PLATEIDS[npoints]
  • LMPOOL: CSPICE_LMPOOL, length, cvals[]
  • LPARSE: CSPICE_LPARSE, `list`, `delim`, n_max, ITEMS[]
  • LSPCN: double = CSPICE_LSPCN( `body`, et, `abcorr` )
  • LTIME: CSPICE_LTIME, etobs, obs, `dir`, targ, ETTARG, ELAPSD

M Top
  • M2EUL: CSPICE_M2EUL, r[3,3], axis3, axis2, axis1, ANGLE3, ANGLE2, ANGLE1
  • M2Q: CSPICE_M2Q, r[3,3], Q[4]
  • MATCHI: boolean = CSPICE_MATCHI( `string`, `templ`, `wstr`, `wchr` )
  • MATCHW: boolean = CSPICE_MATCHW( `string`, `templ`, `wstr`, `wchr` )
  • MEQU: CSPICE_MEQU, m1[3,3], MOUT[3,3]
  • MTXM: CSPICE_MTXM, m1[3,3], m2[3,3], MOUT[3,3]
  • MTXV: CSPICE_MTXV, m1[3,3], vin[3], VOUT[3]
  • MXM: CSPICE_MXM, m1[3,3], m2[3,3], MOUT[3,3]
  • MXMT: CSPICE_MXMT, m1[3,3], m2[3,3], MOUT[3,3]
  • MXV: CSPICE_MXV, m1[3,3], vin[3], VOUT[3]

N Top
  • NAMFRM: CSPICE_NAMFRM, `frname`, FRCODE
  • NEARPT: CSPICE_NEARPT, positn[3], a, b, c, NPOINT[3], ALT
  • NPEDLN: CSPICE_NPEDLN, a, b, c, linept[3], linedr[3], PNEAR[3], DIST
  • NPELPT: CSPICE_NPELPT, point[3], ellips, PNEAR[3], DIST
  • NPLNPT: CSPICE_NPLNPT, linpt[3], lindir[3], point[3], PNEAR[3], DIST
  • NVC2PL: CSPICE_NVC2PL, normal[3], constant, PLANE
  • NVP2PL: CSPICE_NVP2PL, normal[3], point[3], PLANE

O Top
  • OCCULT: CSPICE_OCCULT, `target1`, `shape1`, `frame1`, `target2`, `shape2`, `frame2`, `abcorr`, `observer` _et_, _OCCULT_CODE_
  • OSCELT: CSPICE_OSCELT, _state[6]_, _et_, mu, _ELTS[8]_

P Top
  • PCKCOV: CSPICE_PCKCOV, `pck`, idcode, (COVER)
  • PCKFRM: CSPICE_PCKCOV, `pck`, idcode, (COVER)
  • PCKLOF: CSPICE_PCKLOF, `fname`, HANDLE
  • PCKUOF: CSPICE_PCKUOF, handle
  • PCPOOL: CSPICE_PCPOOL, `name`, length, cvals[]
  • PDPOOL: CSPICE_PDPOOL, `name`, dvals[]
  • PGRREC: CSPICE_PGRREC, `body`, _lon_, _lat_, _alt_, re, f, _RECTAN[3]_
  • PHASEQ: double = CSPICE_PHASEQ( et, `target`, `illumn`, `obsrvr`, `abcorr` )
  • PI: double = CSPICE_PI()
  • PIPOOL: CSPICE_PIPOOL, `name`, ivals[]
  • PJELPL: CSPICE_PJELPL, elin, plane, ELOUT
  • PL2NVC: CSPICE_PL2NVC, plane, NORMAL[3], CONSTANT
  • PL2NVP: CSPICE_PL2NVP, plane, NORMAL[3], POINT[3]
  • PL2PSV: CSPICE_PL2PSV, plane, POINT[3], SPAN1[3], SPAN2[3]
  • PLTAR: double = CSPICE_PLTAR( vrtces[3,NV], plates[3,NP] )
  • PLTEXP: CSPICE_PLTEXP, iverts[3,3], delta, OVERTS[3,3]
  • PLTNP: CSPICE_PLTNP, point[3], v1[3], v2[3], v3[3], PNEAR[3], DIST
  • PLTNRM: CSPICE_PLTNRM, v1[3], v2[3], v3[3], NORMAL[3]
  • PLTVOL: double = CSPICE_PLTVOL( vrtces[3,NV], plates[3,NP] )
  • PROP2B: CSPICE_PROP2B, gm, pvinit[6], dt, PVPROP[6]
  • PRSDP: CSPICE_PRSDP, `string`, DPVAL
  • PRSINT: CSPICE_PRSINT, `string`, INTVAL
  • PSV2PL: CSPICE_PSV2PL, point[3], span1[3], span2[3], PLANE
  • PXFORM: CSPICE_PXFORM, `from`, `to`, _et_, _ROTATE[3,3]_
  • PXFRM2: CSPICE_PXFRM2, `from`, `to`, _etfrom_, _etto_, _ROTATE[3,3]_

Q Top
  • Q2M: CSPICE_Q2M, q[4], R[3,3]
  • QDQ2AV: CSPICE_QDQ2AV, q[4], dq[4], AV[3]
  • QXQ: CSPICE_QXQ, q1[4], q2[4], QOUT[4]

R Top
  • RADREC: CSPICE_RADREC, _range_, _ra_, _dec_, _RECTAN[3]_
  • RAV2XF: CSPICE_RAV2XF, rot[3,3], av[3], XFORM[6,6]
  • RAXISA: CSPICE_RAXISA, matrix[3,3], AXIS[3], ANGLE
  • RECCYL: CSPICE_RECCYL, _rectan[3]_, _R_, _LON_, _Z_
  • RECGEO: CSPICE_RECGEO, _rectan[3]_, re, f, _LON_, _LAT_, _ALT_
  • RECLAT: CSPICE_RECLAT, _rectan[3]_, _RADIUS_, _LONGITUDE_, _LATITUDE_
  • RECPGR: CSPICE_RECPGR, body, _rectan[3]_, re, f, _LON_, _LAT_, _ALT_
  • RECRAD: CSPICE_RECRAD, _rectan[3]_, _RADIUS_, _RA_, _DEC_
  • RECSPH: CSPICE_RECSPH, _rectan[3]_, _R_, _COLAT_, _LON_
  • REMOVD: CSPICE_REMOVD, _item_, (SET)
  • REMOVI: CSPICE_REMOVI, _item_, (SET)
  • ROTATE: CSPICE_ROTATE, angle, iaxis, MOUT[3,3]
  • ROTMAT: CSPICE_ROTMAT, m1[3,3], angle, iaxis, MOUT[3,3]
  • ROTVEC: CSPICE_ROTVEC, v1[3], angle, iaxis, VOUT[3]
  • RPD: double = CSPICE_RPD()
  • RQUAD: CSPICE_RQUAD, a, b, c, ROOT1[2], ROOT2[2]

S Top
  • SAELGV: CSPICE_SAELGV, vec1[3], vec2[3], SMAJOR[3], SMINOR[3]
  • SCARD: CSPICE_SCARD, card, (CELL)
  • SCDECD: CSPICE_SCDECD, sc, _sclkdp_, _`SCLKCH`_
  • SCE2C: CSPICE_SCE2C, sc, _et_, _SCLKDP_
  • SCE2S: CSPICE_SCE2S, sc, et, `SCLKCH`
  • SCE2T: CSPICE_SCE2T, sc, et, SCLKDP
  • SCENCD: CSPICE_SCENCD, sc, _`sclkch`_, _SCLKDP_
  • SCFMT: CSPICE_SCFMT, sc, ticks, `CLKSTR`
  • SCPART: CSPICE_SCPART, sc, PSTART[], PSTOP[]
  • SCS2E: CSPICE_SCS2E, sc, _`sclkch`_, _ET_
  • SCT2E: CSPICE_SCT2E, sc, sclkdp, ET
  • SCTIKS: CSPICE_SCTIKS, sc, `clkstr`, TICKS
  • SDIFF: CSPICE_SDIFF, a, b, (C)
  • SET: boolean = CSPICE_SET( a, `op`, b)
  • SINCPT: CSPICE_SINCPT, `method`,`target`, et, `fixref`, `abcorr`, `obsrvr`, `dref`, dvec[3], SPOINT[3], TRGEPC, SRFVEC[3], FOUND
  • SIZE: integer = CSPICE_SIZE( (cell) )
  • SPD: double = CSPICE_SPD()
  • SPHCYL: CSPICE_SPHCYL, radius, colat, slon, R, LON, Z
  • SPHLAT: CSPICE_SPHLAT, r, colat, lons, RADIUS, LON, LAT
  • SPHREC: CSPICE_SPHREC, _r_, _colat_, _lon_, _RECTAN[3]_
  • SPK14A: CSPICE_SPK14A, handle, ncsets, coeffs[], epochs[]
  • SPK14B: CSPICE_SPK14B, handle, `segid`, body, center, `frame`, first, last, chbdeg
  • SPK14E: CSPICE_SPK14E, handle
  • SPKAPO: CSPICE_SPKAPO, targ, et, `ref`, sobs[6], `abcorr`, PTARG[3], LTIME
  • SPKAPP: CSPICE_SPKAPP, targ, et, `ref`, sobs[6], `abcorr`, STARG[6], LTIME
  • SPKCLS: CSPICE_SPKCLS, handle
  • SPKCOV: CSPICE_SPKCOV, `spk`, idcode, (COVER)
  • SPKCPO: CSPICE_SPKCPO, `target`, et, `outref`, `refloc`, `abcorr,` obspos[3], `obsctr`, `obsref`, STARG[6], LTIME
  • SPKCPT: CSPICE_SPKCPT, trgpos[3], `trgctr`, `trgref`, et, `outref`, `evlref`, `abcorr`, `obsrv`, STARG[6], LTIME
  • SPKCVO: CSPICE_SPKCVO, `target`, et, `outref`, `evlref`, `abcorr,` obssta[6], obsepc, `obsctr`, `obsref`, STARG[6], LTIME
  • SPKCVT: CSPICE_SPKCVT, trgsta[6], trgepc, `trgctr`, `trgref`, et, `outref`, `evlref`, `abcorr`, `obsrv`, STARG[6], LTIME
  • SPKEZ: CSPICE_SPKEZ, targ, et, `ref`, `abcorr`, obs, STATE[6], LTIME
  • SPKEZP: CSPICE_SPKEZP, targ, et, `ref`, `abcorr`, obs, PTARG[3], LTIME
  • SPKEZR: CSPICE_SPKEZR, `targ`, _et_, `ref`, `abcorr`, `obs`, _STARG[6]_, _LTIME_
  • SPKGEO: CSPICE_SPKGEO, targ, et, `ref`, obs, STATE[6], LTIME
  • SPKGPS: CSPICE_SPKGPS, targ, et, `ref`, obs, POS[3], LTIME
  • SPKLEF: CSPICE_SPKLEF, `filename`, HANDLE
  • SPKOBJ: CSPICE_SPKOBJ, spk, (IDS)
  • SPKOPA: CSPICE_SPKOPA, `file`, HANDLE
  • SPKOPN: CSPICE_SPKOPN, `name`, `ifname`, ncomch, HANDLE
  • SPKPOS: CSPICE_SPKPOS, `targ`, _et_, `ref`, `abcorr`, `obs`, _PTARG[3]_, _LTIME_
  • SPKPVN: CSPICE_SPKPVN, handle, descr[5], et, REF, STATE[6], CENTER
  • SPKSFS: CSPICE_SPKSFS, body, et, HANDLE, DESCR[5], IDENT, FOUND
  • SPKSSB: CSPICE_SPKSSB, targ, et, `ref`, STARG[6]
  • SPKUDS: CSPICE_SPKUDS, BODY, CENTER, FRAME, TYPE, FIRST, LAST, BEGIN, END
  • SPKUEF: CSPICE_SPKUEF, handle
  • SPKW02: CSPICE_SPKW02, handle, body, center, `frame`, first, last, `segid`, intlen, n, polydg, cdata[], btime
  • SPKW03: CSPICE_SPKW03, handle, body, center, `frame`, first, last, `segid`, intlen, n, polydg, cdata[], btime
  • SPKW05: CSPICE_SPKW05, handle, body, center, `frame`, first, last, `segid`, gm, n, states[6,N], epochs[N]
  • SPKW08: CSPICE_SPKW08, handle, body, center, `frame`, first, last, `segid`, degree, n, states[6,N], epoch1, step
  • SPKW09: CSPICE_SPKW09, handle, body, center, `frame`, first, last, `segid`, degree, n, states[6,N], epochs[N]
  • SPKW10: CSPICE_SPKW10, handle, body, center, `frame`, first, last, `segid`, consts[8], n, elems[10*n], epochs[n]
  • SPKW12: CSPICE_SPKW12, handle, body, center, `frame`, first, last, `segid`, degree, n, states[6,N], epoch0, step
  • SPKW13: CSPICE_SPKW13, handle, body, center, `frame`, first, last, `segid`, degree, n, states[6,N], epochs[N]
  • SPKW17: CSPICE_SPKW17, handle, body, center, `frame`, first, last, `segid`, epoch, eqel[9], rapol, decpol
  • SRFC2S: CSPICE_SRFC2S, code, bodyid, `SRFSTR`, ISNAME
  • SRFCSS: CSPICE_SRFCSS, code, `bodstr`, `SRFSTR`, ISNAME
  • SRFNRM: CSPICE_SRFNRM, `method`, `target`, et, `fixref`, srfpts[3,N], NORMLS[3,N]
  • SRFREC: CSPICE_SRFREC, body, _longitude_, _latitude_, _RECTAN[3]_
  • SRFS2C: CSPICE_SRFS2C, `srfstr`, `bodstr`, CODE, FOUND
  • SRFSCC: CSPICE_SRFSCC, `surfce`, bodyid, SURFID, FOUND
  • SRFXPT: CSPICE_SRFXPT, `method`, `target`, _et_, `abcorr`, `obsrvr`, `dref`, dvec[3], _SPOINT[3]_, _DIST_, _TRGEPC_, _OBSPOS[3]_, _FOUND_
  • SSIZE: CSPICE_SSIZE, size, (CELL)
  • STELAB: CSPICE_STELAB, pobj[3], vobs[3], APPOBJ[3]
  • STPOOL: CSPICE_STPOOL, `item`, nth, `contin`, `STRING`, SIZE, FOUND
  • STR2ET: CSPICE_STR2ET, _`str`_, _ET_
  • SUBPNT: CSPICE_SUBPNT, `method`, `target`, et, `fixref`, `abcorr`, `obsrvr`, SPOINT[3], TRGEPC, SRFVEC[3]
  • SUBPT: CSPICE_SUBPT, `method`, `target`, _et_, `abcorr`, `obsrvr`, _SPOINT[3]_, _ALT_
  • SUBPT_PL02: CSPICE_SUBPT_PL02, handle, dladsc[SPICE_DLA_DSCSIZ], `method`, `target`, et, `abcorr`, `obsrvr`, SPOINT[3], ALT, PLID
  • SUBSLR: CSPICE_SUBSLR, `method`, `target`, et, `fixref`, `abcorr`, `obsrvr`, SPOINT[3], TRGEPC, SRFVEC[3]
  • SUBSOL: CSPICE_SUBSOL, `method`, `target`, et, `abcorr`, `obsrvr`, SPOINT[3]
  • SUBSOL_PL02: CSPICE_SUBSOL_PL02, handle, dladsc[SPICE_DLA_DSCSIZ], `method`, `target`, et, `abcorr`, `obsrvr`, SPOINT[3], DIST, PLID
  • SUMAD: double = CSPICE_SUMAD( array[], n )
  • SUMAI: integer = CSPICE_SUMAI( array[], n )
  • SURFNM: CSPICE_SURFNM, a, b, c, point[3], NORMAL[3]
  • SURFPT: CSPICE_SURFPT, positn[3], u[3], a, b, c, POINT[3], FOUND
  • SXFORM: CSPICE_SXFORM, `from`, `to`, _et_, _XFORM[6,6]_
  • SZPOOL: CSPICE_SZPOOL, `name`, N, FOUND

T Top
  • TERMPT: CSPICE_TERMPT, `method`, `ilusrc`, `target`, et, `fixref`, `abcorr`, corloc, `obsrvr`, refvec, rolstp, ncuts, schstp, soltol, maxn, NPTS[maxn], POINTS[3,maxn], EPOCHS[maxn], TANGTS[3,maxn]
  • TERM_PL02: CSPICE_TERM_PL02, handle, dladsc[SPICE_DLA_DSCSIZ], `trmtyp`, `source', `target`, et, `fixfrm`, `abcorr`, `obsrvr`, npoints, TRGEPC, OBSPOS[3], TERMPTS[3, npoints], PLATEIDS[npoints]
  • TIMDEF: CSPICE_TIMDEF, `action`, `item`, `(VALUE)`
  • TIMOUT: CSPICE_TIMOUT, _et_, `pictur`, lenout, _`OUTPUT`_
  • TIPBOD: CSPICE_TIPBOD, `ref`, body, et, TIPM[3,3]
  • TISBOD: CSPICE_TISBOD, `ref`, body, et, TSIPM[6,6]
  • TKVRSN: string = CSPICE_TKVRSN( `item` )
  • TPARSE: CSPICE_TPARSE, `string`, SP2000, `ERRMSG`
  • TPICTR: CSPICE_TPICTR, `sample`, lenout, `PICTUR`, OK, `ERROR`
  • TRACE: double = CSPICE_TRACE( matrix[3,3] )
  • TSETYR: CSPICE_TSETYR, year
  • TWOPI: double = CSPICE_TWOPI()
  • TWOVEC: CSPICE_TWOVEC, axdef[3], indexa, plndef[3], indexp, MOUT[3,3]
  • TYEAR: double = CSPICE_TYEAR()

U Top
  • UCASE: CSPICE_UCASE, `in`, `OUT`
  • UCRSS: CSPICE_UCRSS, v1[3], v2[3], VOUT[3]
  • UNION: CSPICE_UNION, a, b, (C)
  • UNITIM: double = CSPICE_UNITIM( epoch, `insys`, `outsys` )
  • UNLOAD: CSPICE_UNLOAD, `file`
  • UNORM: CSPICE_UNORM, v1[3], VOUT[3], VMAG
  • UNORMG: CSPICE_UNORMG, v1[], VOUT[], VMAG
  • UTC2ET: CSPICE_UTC2ET, `utcstr`, ET

V Top
  • VADD: CSPICE_VADD, v1[3], v2[3], VOUT[3]
  • VADDG: CSPICE_VADDG, v1[], v2[], VOUT[]
  • VALID: CSPICE_VALID, size, n, (SET)
  • VCRSS: CSPICE_VCRSS, v1[3], v2[3], VOUT[3]
  • VDIST: double = CSPICE_VDIST( v1[3], v2[3] )
  • VDISTG: double = CSPICE_VDISTG( v1[], v2[] )
  • VDOT: double = CSPICE_VDOT( v1[3], v2[3] )
  • VDOTG: double = CSPICE_VDOTG( v1[], v2[] )
  • VEQU: CSPICE_VEQU, vin[3], VOUT[3]
  • VEQUG: CSPICE_VEQUG, vin[], VOUT[]
  • VHAT: CSPICE_VHAT, v1[3], VOUT[3]
  • VHATG: CSPICE_VHATG, v1[], VOUT[]
  • VLCOM: CSPICE_VLCOM, a, v1[3], b, v2[3], SUM[3]
  • VLCOM3: CSPICE_VLCOM3, a, v1[3], b, v2[3], c, v3[3], SUM[3]
  • VLCOMG: CSPICE_VLCOMG, a, v1[], b, v2[], SUM[]
  • VMINUG: CSPICE_VMINUG, vin[], VOUT[]
  • VMINUS: CSPICE_VMINUS, v1[3], VOUT[3]
  • VNORM: double = CSPICE_VNORM( v1[3] )
  • VNORMG: double = CSPICE_VNORMG( v1[] )
  • VPACK: CSPICE_VPACK, x, y, z, V[3]
  • VPERP: CSPICE_VPERP, a[3], b[3], P[3]
  • VPRJP: CSPICE_VPRJP, vin[3], plane, VOUT[3]
  • VPRJPI: CSPICE_VPRJPI, vin[3], projpl, invpl, VOUT[3], FOUND
  • VPROJ: CSPICE_VPROJ, a[3], b[3], P[3]
  • VREL: double = CSPICE_VREL( v1[3], v2[3] )
  • VRELG: double = CSPICE_VRELG( v1[], v2[] )
  • VROTV: CSPICE_VROTV, v[3], axis[3], theta, R[3]
  • VSCL: CSPICE_VSCL, s, v1[3], VOUT[3]
  • VSCLG: CSPICE_VSCLG, s, v1[], VOUT[]
  • VSEP: double = CSPICE_VSEP( v1[3], v2[3] )
  • VSEPG: double = CSPICE_VSEPG( v1[], v2[] )
  • VSUB: CSPICE_VSUB, v1[3], v2[3], VOUT[3]
  • VSUBG: CSPICE_VSUBG, v1[], v2[], VOUT[]
  • VTMV: double = CSPICE_VTMV( v1[3], matrix[3,3], v2[3] )
  • VUPACK: CSPICE_VUPACK, v[3], X, Y, Z
  • VZERO: boolean = CSPICE_VZERO( v[3] )
  • VZEROG: boolean = CSPICE_VZEROG( v[] )

W Top
  • WNCARD: integer = CSPICE_WNCARD( (window) )
  • WNCOMD: CSPICE_WNCOMD, left, right, window, (RESULT)
  • WNCOND: CSPICE_WNCOND, left, right, (WINDOW)
  • WNDIFD: CSPICE_WNDIFD, a, b, (C)
  • WNELMD: boolean = CSPICE_WNELMD( point, window)
  • WNEXPD: CSPICE_WNEXPD, left, right, (WINDOW)
  • WNEXTD: CSPICE_WNEXTD, `side`, (WINDOW)
  • WNFETD: CSPICE_WNFETD, window, n LEFT, RIGHT
  • WNFILD: CSPICE_WNFILD, small, (WINDOW)
  • WNFLTD: CSPICE_WNFLTD, small, (WINDOW)
  • WNINCD: boolean = CSPICE_WNINCD( left, right, window)
  • WNINSD: CSPICE_WNINSD, left, right, (WINDOW)
  • WNINTD: CSPICE_WNINTD, a, b, (C)
  • WNRELD: boolean = CSPICE_WNRELD( a, `op`, b)
  • WNSUMD: CSPICE_WNSUMD, window, MEAS, AVG, STDDEV, SHORTEST, LONGEST
  • WNUNID: CSPICE_WNUNID, a, b, (C)
  • WNVALD: CSPICE_WNVALD, size, n, (WINDOW)

X Top
  • XF2EUL: CSPICE_XF2EUL, xform[6,6], axisa, axisb, axisc, EULANG[6], UNIQUE
  • XF2RAV: CSPICE_XF2RAV, xform[6,6], ROT[3,3], AV[3]
  • XFMSTA: CSPICE_XFMSTA, _input_state[6]_, `input_coord_sys`, `output_coord_sys`, `body`, _OUTPUT_STATE[6]_
  • XPOSE: CSPICE_XPOSE, m1[3,3], MOUT[3,3]
  • XPOSE6: CSPICE_XPOSE6, m1[6,6], MOUT[6,6]