CoreCommon

java.lang.Object
- nxm.ice.lib.CoreCommon

All Implemented Interfaces:

nxm.sys.inc.Constants, nxm.sys.inc.DataTypes

Direct Known Subclasses:

CoreComponent, CoreLibrary, CoreTask
```
public class CoreCommon
extends java.lang.Object
implements nxm.sys.inc.Constants, nxm.sys.inc.DataTypes
```
Common routines for a Code-Once-Run-Everywhere library function

Author:

Jeff Schoen

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`CoreCommon.CxByte`
`static class`	`CoreCommon.CxDouble`
`static class`	`CoreCommon.CxFloat`
`static class`	`CoreCommon.CxShort`
`static class`	`CoreCommon.SxDouble`
`static class`	`CoreCommon.SxFloat`
`static class`	`CoreCommon.SxShort`
`static class`	`CoreCommon.TypeDef`
`static class`	`CoreCommon.VxDouble`
`static class`	`CoreCommon.VxFloat`
`static class`	`CoreCommon.VxShort`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ARRAY`
`static int`	`BUFFER`
`static int`	`BUFSTR`
`static byte[]`	`cvbb`
`static int`	`FLGS`
`static int`	`FLOW`
`static int`	`FORM`
`static int`	`FUNC`
`static int`	`IMPL`
`static int`	`MCID`
`static int`	`PACKET`
`static int`	`SCID`
`static int`	`STREAM`
`static int`	`VBPR`

Fields inherited from interface nxm.sys.inc.Constants
ANGULAR_VELOCITY_PRECESSING_COR, B1G, B1K, B1M, B1T, B64K, CYC2RAD, DEF_EARTH_ANGULAR_VELOCITY, DEG2METERS, DEG2RAD, E, EARTH_ANGULAR_VELOCITY, EARTH_ECCENTRICITY, EARTH_EQUATORIAL_RADIUS, EARTH_FLATTENING_FACTOR, EARTH_GRAV_CONSTANT_W_ATMOS, EARTH_GRAV_CONSTANT_W_ATMOS_ORIG, EARTH_GRAV_CONSTANT_WO_ATMOS, EARTH_GRAV_CONSTANT_WO_ATMOS_ORIG, FEET2METERS, HALFPI, IAU_EARTH_ANGULAR_VELOCITY, LN2DB, LN2LOG, LNTEN, MASS_OF_EARTH_W_ATMOS, METERS2DEG, METERS2FEET, METERS2NM, METERS2SM, NM2FEET, NM2METERS, PI, POLAR_RADIUS_IN_METERS, POLAR_RADIUS_OF_CURVATURE, RAD2CYC, RAD2DEG, SECOND_EARTH_ECCENTRICITY, SM2FEET, SM2METERS, SPEED_OF_LIGHT, TWOPI

Fields inherited from interface nxm.sys.inc.DataTypes
ALAW, AMODE, ASCII, ASCII256, BMAX, BMIN, BOOL, BYTE, COMPLEX, CONVERT_TYPE_LIST, CRAY, DATA_MODE_LIST, DATA_TYPE_LIST, DMAX, DMIN, DOUBLE, EEEI, EXTENDED_DATA_TYPE_LIST, falseStates, FLOAT, FMAX, FMIN, IEEE, IMAX, IMIN, INT, JINT, LMAX, LMIN, LONG, MATRIX, modeList, MULT_DATA_MODE_LIST, NIBBLE, NMAX, NMIN, NONHOMOGENEOUS, NUMBER, numberTypes, NUMERIC_DATA_TYPE_LIST, numericTypeList, OBJECT, PACKED, QUAD, repList, RESULT_TYPE_LIST, SCALAR, STRING, TABLE, TRANSMATRIX, trueStates, typeList, UINT, ULAW, ULONG, VAX, VECTOR, XLONG, XMAX, XMIN, XMODE, XMVALUE, XMVALUE_KVLIST, XMVALUE_LIST, XMVALUE_TABLE

Constructor Summary

Constructors
Constructor and Description

CoreCommon()

Constructors
Constructor and Description
`CoreCommon()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`abs(int x)`
`static void`	`addcc(CoreCommon.CxFloat a, CoreCommon.CxFloat b, CoreCommon.CxFloat c)`
`static double`	`atan2(double x, double y)`
`static float`	`atan2cf(float x, float y)`
`static float`	`atan2f(float x, float y)`
`static int`	`brev4(int val)`
`static short`	`bswap2(int x)`
`static short`	`bswap2(short x)`
`static int`	`bswap2s(int x)`
`static int`	`bswap4(int x)`
`static double`	`ceil(double x)`
`static float`	`ceilf(float x)`
`static byte[]`	`CF2bb(CoreCommon.CxFloat v)`
`static void`	`CF2CI(CoreCommon.CxFloat cf, CoreCommon.CxShort ci)`
`static int`	`CF2L(float fx, float fy)`
`static void`	`CI2CF(CoreCommon.CxShort ci, CoreCommon.CxFloat cf)`
`static float`	`CI2Fx(int i)`
`static float`	`CI2Fy(int i)`
`static int`	`CI2L(short ix, short iy)`
`static double`	`clip(double x, double min, double max)`
`static float`	`clipf(float x, float min, float max)`
`static int`	`clipl(int x, int min, int max)`
`static double`	`cos(double x)`
`static double`	`cosc(double x)`
`static float`	`coscf(double x)`
`static float`	`cosf(double x)`
`static java.lang.String`	`cpuDate()`
`static double`	`cpuTime()`
`static void`	`cpuWait(double sec)`
`CoreCommon.CxByte`	`CxByte()`
`CoreCommon.CxDouble`	`CxDouble_stk()`
`CoreCommon.CxFloat`	`CxFloat_stk()`
`CoreCommon.CxShort`	`CxShort_stk()`
`static long`	`d2dptx(double d)`
`static float`	`d2f(double d)`
`static int`	`d2fi(double f)`
`static int`	`d2i(double d)`
`static long`	`d2l(double d)`
`static int`	`d2wi(double f)`
`static long`	`d2x(double f)`
`static double`	`divdi(double x, int y)`
`static float`	`divf(float x, float y)`
`static float`	`divfi(float x, int y)`
`static float`	`divfp2(float x, int y)`
`static double`	`divii(int x, int y)`
`static double`	`divp2(double x, int y)`
`static double`	`dptx2d(long x)`
`static void`	`dupcc(CoreCommon.CxFloat a, CoreCommon.CxFloat b)`
`static byte[]`	`f2bb(float v)`
`static double`	`f2d(float f)`
`static int`	`f2fptx(float f)`
`static int`	`f2i(float f)`
`static short`	`F2I(float f)`
`static int`	`F2K(float f)`
`static int`	`f2x(float f)`
`static double`	`fabs(double x)`
`static float`	`fabsf(float x)`
`static double`	`fi2d(int f)`
`static int`	`findListItem(java.lang.String sa, java.lang.String sb, int offset)`
`static int`	`fint(double x)`
`static int`	`fintf(float x)`
`static double`	`floor(double x)`
`static float`	`floorf(float x)`
`static double`	`fmax(double x, double y)`
`static float`	`fmaxf(float x, float y)`
`static double`	`fmin(double x, double y)`
`static float`	`fminf(float x, float y)`
`static double`	`fmod(double x, double y)`
`static float`	`fmodf(float x, float y)`
`static int`	`fp2i(float f)`
`static float`	`fptx2f(int x)`
`static double`	`frac(double x)`
`static float`	`fracf(float x)`
`static int`	`gatherBits(int val, int i0, int inc, int n)`
`static boolean`	`getBit(int val, int i)`
`static boolean`	`getBit(long val, int i)`
`static int`	`getBits(int val, int i2, int i1)`
`static int`	`getBits(long val, int i2, int i1)`
`static int`	`getListBase(java.lang.String sa)`
`static java.lang.String`	`getListItem(java.lang.String sa, int index, int offset)`
`static int`	`getPABS(int cur, int val, int len)`
`static long`	`getPABS(long cur, long val, int len)`
`static int`	`getPBBS(int cur, boolean val)`
`static int`	`getPBS(int cur, int val, int i2, int i1)`
`static long`	`getPBS(long cur, long val, int i2, int i1)`
`static byte[]`	`i2bb(int v)`
`static double`	`i2d(int i)`
`static float`	`i2f(int i)`
`static float`	`I2F(short s)`
`static float`	`i2fp(int i)`
`static short`	`i2s(int i)`
`static int`	`iabs(int x)`
`static long`	`ii2l(int ui, int li)`
`static int`	`iLRS(int lrs)`
`static int`	`iLRSP(int lrs, int lrsp)`
`static int`	`imax(int x, int y)`
`static int`	`imin(int x, int y)`
`static int`	`IN2P(int i)`
`static double`	`inv(double x)`
`static float`	`invf(float x)`
`static float`	`invfi(int x)`
`static int`	`IO2P(int i)`
`static float`	`K2F(int i)`
`static double`	`l2d(long l)`
`static float`	`L2F(int i)`
`static int`	`l2i(long l)`
`static short`	`l2s(long l)`
`static long`	`labs(long x)`
`static int`	`LN2P(int i)`
`static int`	`LO2P(int i)`
`static double`	`log10(double x)`
`static float`	`log10cf(CoreCommon.CxFloat v)`
`static float`	`log10f(float x)`
`static double`	`log2(double x)`
`static float`	`mag2f(CoreCommon.CxFloat a)`
`static void`	`msumccf(float[] ax, float[] ay, float[] bx, float[] by, CoreCommon.CxFloat c, int n)`
`static void`	`msumcsf(float[] ax, float[] ay, float[] b, CoreCommon.CxFloat c, int n)`
`static void`	`msumf(float[] a, float[] b, CoreCommon.SxFloat c, int n)`
`static void`	`mulcAc(CoreCommon.CxFloat[] a, CoreCommon.CxFloat b, CoreCommon.CxFloat[] c, int n)`
`static void`	`mulcAcA(CoreCommon.CxFloat[] a, CoreCommon.CxFloat[] b, CoreCommon.CxFloat[] c, int n)`
`static void`	`mulcc(CoreCommon.CxFloat a, CoreCommon.CxFloat b, CoreCommon.CxFloat c)`
`static void`	`mulccA(CoreCommon.CxFloat a, CoreCommon.CxFloat[] b, CoreCommon.CxFloat[] c, int n)`
`static void`	`mulccj(CoreCommon.CxFloat a, CoreCommon.CxFloat b, CoreCommon.CxFloat c)`
`static void`	`mulcf(CoreCommon.CxFloat a, float b, CoreCommon.CxFloat c)`
`static void`	`mulcfrnc(CoreCommon.CxFloat a, float b, CoreCommon.CxFloat c)`
`static double`	`muldf(double x, float y)`
`static double`	`muldi(double x, int y)`
`static void`	`mulfc(float a, CoreCommon.CxFloat b, CoreCommon.CxFloat c)`
`static void`	`mulfcrnc(float a, CoreCommon.CxFloat b, CoreCommon.CxFloat c)`
`static float`	`mulff(float x, float y)`
`static float`	`mulffrnc(float x, float y)`
`static float`	`mulfi(float x, int y)`
`static float`	`mulfp2(float x, int y)`
`static int`	`mulif(int x, float y)`
`static double`	`mulp2(double x, int y)`
`static void`	`muxf(float x, float y, CoreCommon.CxFloat cx)`
`static int`	`ones(int x, int n)`
`static float`	`phaseditherf()`
`static void`	`pol2recf(float amp, float pf, CoreCommon.CxFloat sc)`
`static double`	`pow(double x, double y)`
`static int`	`pow2ge(int num)`
`static int`	`power2ge(int num)`
`static float`	`powf(float x, float y)`
`static void`	`qrotcc(CoreCommon.CxFloat a, int quad, CoreCommon.CxFloat b)`
`static int`	`qwrap2z(CoreCommon.CxFloat a)`
`static double`	`round(double x)`
`static float`	`roundf(float x)`
`static byte[]`	`s2bb(short v)`
`static int`	`s2i(short s)`
`static long`	`s2l(short s)`
`static double`	`sclip(double x, double mm)`
`static float`	`sclipf(float x, float mm)`
`static int`	`sclipl(int x, int mm)`
`static int`	`setBit(int val, int i, boolean valb)`
`static long`	`setBit(long val, int i, boolean valb)`
`static byte`	`setBits(byte val, int i2, int i1, int valb)`
`static int`	`setBits(int val, int i2, int i1, int valb)`
`static long`	`setBits(long val, int i2, int i1, long valb)`
`static short`	`setBits(short val, int i2, int i1, int valb)`
`static double`	`sin(double x)`
`static double`	`sinc(double x)`
`static float`	`sincf(double x)`
`static void`	`sincoscf(float pf, CoreCommon.CxFloat sc)`
`static float`	`sinf(double x)`
`static double`	`sqrt(double x)`
`static float`	`sqrtf(float x)`
`CoreCommon.SxDouble`	`SxDouble_stk()`
`CoreCommon.SxFloat`	`SxFloat_stk()`
`CoreCommon.SxShort`	`SxShort_stk()`
`static double`	`tan(double x)`
`static float`	`tancf(double x)`
`static float`	`tanf(double x)`
`CoreCommon.VxDouble`	`VxDouble_stk()`
`CoreCommon.VxFloat`	`VxFloat_stk()`
`CoreCommon.VxShort`	`VxShort_stk()`
`static double`	`wrap(double x)`
`static float`	`wrapf(float x)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface nxm.sys.inc.DataTypes
createNumberTypes

Field Detail
- FUNC
```
public static final int FUNC
```
  See Also:
  
  Constant Field Values
- FORM
```
public static final int FORM
```
  See Also:
  
  Constant Field Values
- FLOW
```
public static final int FLOW
```
  See Also:
  
  Constant Field Values
- IMPL
```
public static final int IMPL
```
  See Also:
  
  Constant Field Values
- FLGS
```
public static final int FLGS
```
  See Also:
  
  Constant Field Values
- SCID
```
public static final int SCID
```
  See Also:
  
  Constant Field Values
- MCID
```
public static final int MCID
```
  See Also:
  
  Constant Field Values
- VBPR
```
public static final int VBPR
```
  See Also:
  
  Constant Field Values
- ARRAY
```
public static final int ARRAY
```
  See Also:
  
  Constant Field Values
- STREAM
```
public static final int STREAM
```
  See Also:
  
  Constant Field Values
- BUFFER
```
public static final int BUFFER
```
  See Also:
  
  Constant Field Values
- BUFSTR
```
public static final int BUFSTR
```
  See Also:
  
  Constant Field Values
- PACKET
```
public static final int PACKET
```
  See Also:
  
  Constant Field Values
- cvbb
```
public static byte[] cvbb
```

Constructor Detail
- CoreCommon
```
public CoreCommon()
```

Method Detail

SxShort_stk

public CoreCommon.SxShort SxShort_stk()

SxFloat_stk

public CoreCommon.SxFloat SxFloat_stk()

SxDouble_stk

public CoreCommon.SxDouble SxDouble_stk()

CxByte
```
public CoreCommon.CxByte CxByte()
```

CxShort_stk

public CoreCommon.CxShort CxShort_stk()

CxFloat_stk

public CoreCommon.CxFloat CxFloat_stk()

CxDouble_stk

public CoreCommon.CxDouble CxDouble_stk()

VxShort_stk

public CoreCommon.VxShort VxShort_stk()

VxFloat_stk

public CoreCommon.VxFloat VxFloat_stk()

VxDouble_stk

public CoreCommon.VxDouble VxDouble_stk()

getBit

public static boolean getBit(int val,
                             int i)

getBit

public static boolean getBit(long val,
                             int i)

getBits

public static int getBits(int val,
                          int i2,
                          int i1)

getBits

public static int getBits(long val,
                          int i2,
                          int i1)

getPBS

public static int getPBS(int cur,
                         int val,
                         int i2,
                         int i1)

getPBS

public static long getPBS(long cur,
                          long val,
                          int i2,
                          int i1)

getPABS

public static int getPABS(int cur,
                          int val,
                          int len)

getPABS

public static long getPABS(long cur,
                           long val,
                           int len)

getPBBS

public static int getPBBS(int cur,
                          boolean val)

gatherBits

public static int gatherBits(int val,
                             int i0,
                             int inc,
                             int n)

setBit

public static int setBit(int val,
                         int i,
                         boolean valb)

setBit

public static long setBit(long val,
                          int i,
                          boolean valb)

setBits

public static byte setBits(byte val,
                           int i2,
                           int i1,
                           int valb)

setBits

public static short setBits(short val,
                            int i2,
                            int i1,
                            int valb)

setBits

public static int setBits(int val,
                          int i2,
                          int i1,
                          int valb)

setBits

public static long setBits(long val,
                           int i2,
                           int i1,
                           long valb)

cpuTime
```
public static double cpuTime()
```

cpuDate

public static java.lang.String cpuDate()

cpuWait

public static void cpuWait(double sec)

s2i
```
public static int s2i(short s)
```

s2l
```
public static long s2l(short s)
```

i2s
```
public static short i2s(int i)
```

i2f
```
public static float i2f(int i)
```

d2f
```
public static float d2f(double d)
```

d2i
```
public static int d2i(double d)
```

d2l
```
public static long d2l(double d)
```

f2i
```
public static int f2i(float f)
```

l2i
```
public static int l2i(long l)
```

l2s
```
public static short l2s(long l)
```

f2d
```
public static double f2d(float f)
```

i2d
```
public static double i2d(int i)
```

l2d
```
public static double l2d(long l)
```

ii2l

public static long ii2l(int ui,
                        int li)

f2x
```
public static int f2x(float f)
```

d2x
```
public static long d2x(double f)
```

d2fi
```
public static int d2fi(double f)
```

d2wi
```
public static int d2wi(double f)
```

fi2d
```
public static double fi2d(int f)
```

i2fp
```
public static float i2fp(int i)
```

fp2i
```
public static int fp2i(float f)
```

f2fptx
```
public static int f2fptx(float f)
```

fptx2f
```
public static float fptx2f(int x)
```

d2dptx
```
public static long d2dptx(double d)
```

dptx2d
```
public static double dptx2d(long x)
```

F2I
```
public static short F2I(float f)
```

I2F
```
public static float I2F(short s)
```

L2F
```
public static float L2F(int i)
```

K2F
```
public static float K2F(int i)
```

F2K
```
public static int F2K(float f)
```

CI2L

public static int CI2L(short ix,
                       short iy)

CF2L

public static int CF2L(float fx,
                       float fy)

CF2CI

public static void CF2CI(CoreCommon.CxFloat cf,
                         CoreCommon.CxShort ci)

CI2CF

public static void CI2CF(CoreCommon.CxShort ci,
                         CoreCommon.CxFloat cf)

CI2Fx
```
public static float CI2Fx(int i)
```

CI2Fy
```
public static float CI2Fy(int i)
```

IN2P
```
public static int IN2P(int i)
```

LN2P
```
public static int LN2P(int i)
```

IO2P
```
public static int IO2P(int i)
```

LO2P
```
public static int LO2P(int i)
```

s2bb
```
public static byte[] s2bb(short v)
```

i2bb
```
public static byte[] i2bb(int v)
```

f2bb
```
public static byte[] f2bb(float v)
```

CF2bb

public static byte[] CF2bb(CoreCommon.CxFloat v)

imin

public static int imin(int x,
                       int y)

imax

public static int imax(int x,
                       int y)

fminf

public static float fminf(float x,
                          float y)

fmaxf

public static float fmaxf(float x,
                          float y)

fmin

public static double fmin(double x,
                          double y)

fmax

public static double fmax(double x,
                          double y)

abs
```
public static int abs(int x)
```

iabs
```
public static int iabs(int x)
```

labs
```
public static long labs(long x)
```

fabsf
```
public static float fabsf(float x)
```

fabs
```
public static double fabs(double x)
```

sinf
```
public static float sinf(double x)
```

cosf
```
public static float cosf(double x)
```

tanf
```
public static float tanf(double x)
```

atan2f

public static float atan2f(float x,
                           float y)

sincf
```
public static float sincf(double x)
```

coscf
```
public static float coscf(double x)
```

tancf
```
public static float tancf(double x)
```

atan2cf

public static float atan2cf(float x,
                            float y)

invf
```
public static float invf(float x)
```

invfi
```
public static float invfi(int x)
```

sqrtf
```
public static float sqrtf(float x)
```

log10f
```
public static float log10f(float x)
```

roundf
```
public static float roundf(float x)
```

floorf
```
public static float floorf(float x)
```

fracf
```
public static float fracf(float x)
```

wrapf
```
public static float wrapf(float x)
```

ceilf
```
public static float ceilf(float x)
```

fmodf

public static float fmodf(float x,
                          float y)

powf

public static float powf(float x,
                         float y)

fintf
```
public static int fintf(float x)
```

sin
```
public static double sin(double x)
```

cos
```
public static double cos(double x)
```

sinc
```
public static double sinc(double x)
```

cosc
```
public static double cosc(double x)
```

tan
```
public static double tan(double x)
```

atan2

public static double atan2(double x,
                           double y)

inv
```
public static double inv(double x)
```

sqrt
```
public static double sqrt(double x)
```

log10
```
public static double log10(double x)
```

log2
```
public static double log2(double x)
```

round
```
public static double round(double x)
```

floor
```
public static double floor(double x)
```

ceil
```
public static double ceil(double x)
```

frac
```
public static double frac(double x)
```

wrap
```
public static double wrap(double x)
```

fmod

public static double fmod(double x,
                          double y)

pow

public static double pow(double x,
                         double y)

divii

public static double divii(int x,
                           int y)

divdi

public static double divdi(double x,
                           int y)

divp2

public static double divp2(double x,
                           int y)

mulp2

public static double mulp2(double x,
                           int y)

divf

public static float divf(float x,
                         float y)

divfi

public static float divfi(float x,
                          int y)

divfp2

public static float divfp2(float x,
                           int y)

mulfp2

public static float mulfp2(float x,
                           int y)

muldf

public static double muldf(double x,
                           float y)

muldi

public static double muldi(double x,
                           int y)

mulfi

public static float mulfi(float x,
                          int y)

mulff

public static float mulff(float x,
                          float y)

mulif

public static int mulif(int x,
                        float y)

fint
```
public static int fint(double x)
```

muxf

public static void muxf(float x,
                        float y,
                        CoreCommon.CxFloat cx)

phaseditherf
```
public static float phaseditherf()
```

clip

public static double clip(double x,
                          double min,
                          double max)

clipf

public static float clipf(float x,
                          float min,
                          float max)

clipl

public static int clipl(int x,
                        int min,
                        int max)

sclip

public static double sclip(double x,
                           double mm)

sclipf

public static float sclipf(float x,
                           float mm)

sclipl

public static int sclipl(int x,
                         int mm)

bswap2
```
public static short bswap2(int x)
```

bswap2
```
public static short bswap2(short x)
```

bswap2s
```
public static int bswap2s(int x)
```

bswap4
```
public static int bswap4(int x)
```

brev4
```
public static int brev4(int val)
```

iLRS
```
public static int iLRS(int lrs)
```

iLRSP

public static int iLRSP(int lrs,
                        int lrsp)

ones

public static int ones(int x,
                       int n)

qwrap2z

public static int qwrap2z(CoreCommon.CxFloat a)

qrotcc

public static void qrotcc(CoreCommon.CxFloat a,
                          int quad,
                          CoreCommon.CxFloat b)

dupcc

public static void dupcc(CoreCommon.CxFloat a,
                         CoreCommon.CxFloat b)

sincoscf

public static void sincoscf(float pf,
                            CoreCommon.CxFloat sc)

pol2recf

public static void pol2recf(float amp,
                            float pf,
                            CoreCommon.CxFloat sc)

addcc

public static void addcc(CoreCommon.CxFloat a,
                         CoreCommon.CxFloat b,
                         CoreCommon.CxFloat c)

mulfc

public static void mulfc(float a,
                         CoreCommon.CxFloat b,
                         CoreCommon.CxFloat c)

mulcf

public static void mulcf(CoreCommon.CxFloat a,
                         float b,
                         CoreCommon.CxFloat c)

mulcc

public static void mulcc(CoreCommon.CxFloat a,
                         CoreCommon.CxFloat b,
                         CoreCommon.CxFloat c)

mulccj

public static void mulccj(CoreCommon.CxFloat a,
                          CoreCommon.CxFloat b,
                          CoreCommon.CxFloat c)

mulffrnc

public static float mulffrnc(float x,
                             float y)

mulfcrnc

public static void mulfcrnc(float a,
                            CoreCommon.CxFloat b,
                            CoreCommon.CxFloat c)

mulcfrnc

public static void mulcfrnc(CoreCommon.CxFloat a,
                            float b,
                            CoreCommon.CxFloat c)

mag2f

public static float mag2f(CoreCommon.CxFloat a)

log10cf

public static float log10cf(CoreCommon.CxFloat v)

mulccA

public static void mulccA(CoreCommon.CxFloat a,
                          CoreCommon.CxFloat[] b,
                          CoreCommon.CxFloat[] c,
                          int n)

mulcAc

public static void mulcAc(CoreCommon.CxFloat[] a,
                          CoreCommon.CxFloat b,
                          CoreCommon.CxFloat[] c,
                          int n)

mulcAcA

public static void mulcAcA(CoreCommon.CxFloat[] a,
                           CoreCommon.CxFloat[] b,
                           CoreCommon.CxFloat[] c,
                           int n)

pow2ge
```
public static int pow2ge(int num)
```

power2ge
```
public static int power2ge(int num)
```

msumf

public static void msumf(float[] a,
                         float[] b,
                         CoreCommon.SxFloat c,
                         int n)

msumcsf

public static void msumcsf(float[] ax,
                           float[] ay,
                           float[] b,
                           CoreCommon.CxFloat c,
                           int n)

msumccf

public static void msumccf(float[] ax,
                           float[] ay,
                           float[] bx,
                           float[] by,
                           CoreCommon.CxFloat c,
                           int n)

getListBase

public static int getListBase(java.lang.String sa)

findListItem

public static int findListItem(java.lang.String sa,
                               java.lang.String sb,
                               int offset)

getListItem

public static java.lang.String getListItem(java.lang.String sa,
                                           int index,
                                           int offset)

Class CoreCommon

Nested Class Summary

Field Summary

Fields inherited from interface nxm.sys.inc.Constants

Fields inherited from interface nxm.sys.inc.DataTypes

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface nxm.sys.inc.DataTypes

Field Detail

FUNC

FORM

FLOW

IMPL

FLGS

SCID

MCID

VBPR

ARRAY

STREAM

BUFFER

BUFSTR

PACKET

cvbb

Constructor Detail

CoreCommon

Method Detail

SxShort_stk

SxFloat_stk

SxDouble_stk

CxByte

CxShort_stk

CxFloat_stk

CxDouble_stk

VxShort_stk

VxFloat_stk

VxDouble_stk

getBit

getBit

getBits

getBits

getPBS

getPBS

getPABS

getPABS

getPBBS

gatherBits

setBit

setBit

setBits

setBits

setBits

setBits

cpuTime

cpuDate

cpuWait

s2i

s2l

i2s

i2f

d2f

d2i

d2l

f2i

l2i

l2s

f2d

i2d

l2d

ii2l

f2x

d2x

d2fi

d2wi

fi2d

i2fp

fp2i

f2fptx

fptx2f

d2dptx