Uses of Class vec_math.NVector

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Class
vec_math.NVector

Packages that use NVector
astro
astro.fits
jview
stella.adapter
stella.jview
stella.math
stella.parameter
stella.telescope
stella.util
util
util.rmi
vec_math
view

Uses of NVector in astro

Methods in astro that return NVector
`NVector`	`WcsMatch.invert(NVector result, Dimension chip)` From the chip size, invert the solution and return the central ra, de in 0/1, the pixel scale in arcsec/pixel in 2 and the field rotation in degrees in 3.
`protected NVector`	`WcsShift.process(String[] arg)` Process the command line and returns a eight-dimensional vector, with the following meaning in its coordinates.
`NVector`	`WcsMatch.solve()` Solves for a solution using previously defined catalog and measures.

Methods in astro with parameters of type NVector
`double`	`WcsMatch.Stereographic.eval(NVector v, boolean print)`
`double`	`WcsMatch.Stereographic.evaluate(NVector v)`
`double`	`OrbitModel.evaluateModel(NVector a, NVector t)` The model that fits an SB-1 orbit is given by
`protected Vector2D`	`WcsMatch.Stereographic.getDisplacement(NVector v, Vector3D star, Vector3D pix)` Returns the displacement to the current solution of a single star.
`Matrix`	`OrbitModel.getGradientMatrix(NVector a)` This is the derivative matrix of the orbital solution with respect to the parameters.
`double[]`	`OrbitModel.getModel(NVector a)` The model that fits an SB-1 orbit is given by
`private static double`	`OrbitModel.getOrbitSolution(double t, NVector a)` Calculates the orbit rv for the given time and the specified parameter set.
`NVector`	`WcsMatch.invert(NVector result, Dimension chip)` From the chip size, invert the solution and return the central ra, de in 0/1, the pixel scale in arcsec/pixel in 2 and the field rotation in degrees in 3.
`void`	`SkyPath.lineTo(NVector star)` Similar to the general path line to, we move out path iterator to a new point on the sphere.
`void`	`SkyPath.moveTo(NVector star)` Similar to the general path move to, we move out path iterator to a new point on the sphere.
`DataModel`	`OrbitFit.prepareFit(NVector[] in)` We try to solve for the orbit, if the period set in the properties is a valid choice.

Constructors in astro with parameters of type NVector
`OrbitModel(NVector[] times, double[] y, double[] err, double off)` Measures at differnt point-in-time.

Uses of NVector in astro.fits

Fields in astro.fits declared as NVector
`private NVector`	`CrosstalkDark.scale1` The 4Vector of scaling values in the early darks.
`private NVector`	`CrosstalkDark.scale2` The 4Vector of scaling values in the early darks.

Methods in astro.fits that return NVector
`private NVector[]`	`CrosstalkDark.getAlphBeta(File amp)` For a fits file, read its scaling factors and return the alpha and beta scaling to all its quadrants as a length-of-two array of 4-Vectors.
`private NVector`	`CrosstalkDark.getDarkScaling(List<nom.tam.fits.ImageHDU> dark)` Tries to read a list of dark, single-extension images, belonging to a single dark, ordered by amplifier.
`private NVector`	`CrosstalkDark.readWifsip(File amp)` Reads all four extension of a fits file, calculates for each the scaling factor, and return those as a four-vector.
`private static NVector`	`Overscan.solveFor(Overscan.Solver s, GradientModel exp, NVector start, NVector len)` Takes a differtiable model of the non-linear gradient region and fits it with one of the specified solvers.
`NVector`	`FitsTools.GnomicProjection.toUserSpace(Point2D norm)` Converts a normalized pixel to ra/dec.

Methods in astro.fits that return types with arguments of type NVector
`static List<NVector>`	`FitsStatistic.extractBackground(double[][] src, nom.tam.fits.ImageHDU sig, int nreject, double lofac, double hifac)` We get all the sky-background pixel in the image hdu by searching for the mode and retaining all pixel +/- lofac and hifac around it in term of adu-sigmas.
`static List<NVector>`	`FitsStatistic.extractBackground(nom.tam.fits.ImageHDU sky, nom.tam.fits.ImageHDU sig, int nreject, double lofac, double hifac)` We get all the sky-background pixel in the image hdu by searching for the mode and retaining all pixel +/- lofac and hifac around it in term of adu-sigmas.

Methods in astro.fits with parameters of type NVector
`private static double`	`CrosstalkDark.averageIndex(NVector v, int i0)` Takes the statistical mean over all indices in the vector except the one stated in i0.
`double`	`FitsStatistic.Constant.evaluate(NVector v)` Return 1.
`double`	`FitsStatistic.XY.evaluate(NVector v)` Return 1.
`double`	`FitsStatistic.Coordinate.evaluate(NVector v)` Return 1.
`double`	`FitsStatistic.Square.evaluate(NVector v)` Return 1.
`double`	`Overscan.WifsipOverscan.evaluateModel(NVector curfit, NVector t)` Returns the model adu for the queried row in vector t, which again is a Vector1D, t.a0 = row.
`Matrix`	`Overscan.WifsipOverscan.getGradientMatrix(NVector curfit)` Returns the matrix that is the gradient to the two-exponential model.
`static double[]`	`Overscan.nonlinearFit(Class<? extends AbstractGradientModel> wifsip, int max, double[][] adu, NVector start, NVector len, double maxrms)` Tries to fit outside the region.
`private static String`	`CrosstalkDark.pretty(NVector v)` Converts an alpha or beta vector to a pretty print.
`private static NVector`	`Overscan.solveFor(Overscan.Solver s, GradientModel exp, NVector start, NVector len)` Takes a differtiable model of the non-linear gradient region and fits it with one of the specified solvers.
`private nom.tam.fits.Fits`	`CrosstalkDark.subtractScaledDark(File f, NVector alpha, NVector beta)` From a file f we read all HDUs and scale them such that the dark sky is (partly) removed.
`Point2D`	`FitsTools.GnomicProjection.toNormalizedSpace(NVector star)` Converts ra/dec to normalized pixel.

Method parameters in astro.fits with type arguments of type NVector
`nom.tam.fits.Fits`	`AmplifierCrosstalk.Simul.createFits(int q0, List<NVector> quad, Point2D p0, double r1, double r2, double adu, double dscale, Dimension size)` Creates an artificial fits object.
`static GeneralLinearRegression`	`FitsStatistic.shuffleForRegression(List<NVector> valid, Multidimensional[] model, boolean sigma)` Shuffels ADU 4-vectors with x, y, ADU, [sigma] into the format for a general linear regression and fuels them into one.

Constructors in astro.fits with parameters of type NVector
`Overscan.WifsipOverscan(NVector[] row, double[] aduav, double[] aduerr)` The array of NVectors actually only contains the row number of the fit, i.e.

Uses of NVector in jview

Fields in jview declared as NVector
`private NVector`	`DssTransformation.amdx` Plate solution x coeffiecients.
`private NVector`	`DssTransformation.amdy` Plate solution y coeffiecients.
`private NVector[]`	`JAsynchronAnalyser.AnalyserThread.in` The analyser's data.
`private NVector[]`	`JAbstractAnalyser.input` The analyser input data constructed from the data card set.
`private NVector`	`DssTransformation.orientation` Orientation coefficients, only index 2 and 5 used.
`private NVector[]`	`JExtremaSelect.power` And the visualized data.
`private NVector`	`JDataCanvas.xspan` From all coordinates, the current span in x plus error.
`private NVector`	`JDataCanvas.yspan` From all coordinates, the current span in y plus error.

Fields in jview with type parameters of type NVector
`private Map<String,List<NVector>>`	`JExpressionFrame.data` The original data.
`private Map<String,NVector>`	`JDataCanvas.xminmax` For each color the current min/max of the x-coordinate.
`private Map<String,NVector>`	`JDataCanvas.yminmax` For each color the current min/max of the y-coordinate.

Methods in jview that return NVector
`private NVector`	`JExpressionCanvas.calculate(String set, NVector org, Map<String,Number> ext)` Tries to calculate an expression for the given vector.
`NVector[]`	`JAbstractAnalyser.getAnalyserInput()` As a source for the analysers, we use the original data, as it comes with error bars.
`NVector[]`	`DataAnalysing.getAnalyserInput()` This method delivers data that should be analysed in an analyser `#process` method.
`protected static NVector`	`AbstractTransferProxy.getBottomRight(UserCoordinates src, Rectangle2D norm)` Returns the bottom-right corner in user space of a normalized rectangle using the provided `UserCoordinates`.
`private static NVector`	`JDataCanvas.getMinMax(List<DataCard> nvector, boolean ad, int index, int erridx)` Takes a list of `NVector`s and returns the maximum and minimum found at the specified index as index 0/1.
`private static NVector`	`JDataCanvas.getSpan(Collection<NVector> vec2d, boolean ad)` Takes a collection of 2d vectors and gets the minimum of x and y.
`protected static NVector`	`AbstractTransferProxy.getUpLeft(UserCoordinates src, Rectangle2D norm)` Returns the upper-left corner in user space of a normalized rectangle using the provided `UserCoordinates`.
`NVector`	`OrthographicTransformation.toUserDistance(Rectangle2D norm)` Converts a distance in normalized space to s distance in user space.
`NVector`	`JFitsCanvas.PixelCoordinate.toUserDistance(Rectangle2D norm)` Converts a distance in normalized space to s distance in user space.
`NVector`	`DeltaTransforming.toUserDistance(Rectangle2D delta)` Converts a distance at normalized pixel `location` into a `NVector` of a distance in user space.
`NVector`	`CylindricalProjection.toUserDistance(Rectangle2D norm)` We call the `CylindricalProjection.toUserSpace(java.awt.geom.Point2D)` twice and return the difference.
`NVector`	`BasicTransform.toUserDistance(Rectangle2D delta)` In the this simple case, a delta transformation is simply scaled by the boxing rectangle size.
`NVector`	`Transform2D.toUserSpace(Point2D norm)` Converts normalized coordinates to user space.
`NVector`	`SelectTransform.toUserSpace(Point2D ab)` We call the super method and return a vector of dimension equal to the maximum of `SelectTransform.x` and `SelectTransform.y`.
`NVector`	`OrthographicTransformation.toUserSpace(Point2D pixel)` This conversation is non-unique, but we assume the solution closer to the center of projection to be the correct one.
`NVector`	`JFitsCanvas.PixelCoordinate.toUserSpace(Point2D norm)` Converts the normalized coordinates to user space.
`NVector`	`DssTransformation.toUserSpace(Point2D norm)` Converts normalized coordinates into user space, i.e.
`NVector`	`CylindricalProjection.toUserSpace(Point2D pix)` Converts normalized space into user space.
`NVector`	`CoordinateTransforming.toUserSpace(Point2D norm)` Converts a pixel in normalized space back to user space.
`NVector`	`BasicTransform.toUserSpace(Point2D ab)` This is the inverse to `BasicTransform.toNormalizedSpace(vec_math.NVector)`.

Methods in jview that return types with arguments of type NVector
`protected List<NVector>`	`JExpressionFrame.getData(String setname)` Gets the original data.

Methods in jview with parameters of type NVector
`int`	`JDataCanvas.addMeasure(NVector point)` Whenever we add a data point, we recalculate the drawable list and the user transform.
`int`	`JExpressionCanvas.addMeasure(String setname, NVector onepoint, Object key)` Add a point specifying the set name instead of the set color.
`int`	`JDataCanvas.addMeasure(String setname, NVector onepoint, Object key)` Add a point specifying the set name instead of the set color.
`private NVector`	`JExpressionCanvas.calculate(String set, NVector org, Map<String,Number> ext)` Tries to calculate an expression for the given vector.
`boolean`	`JExtremaSelect.displayData(NVector[] visual)` We display the data from the analyser.
`boolean`	`DataDisplaying.displayData(NVector[] all)` Grabs a whole set of measured data and takes the interesting part out of it.
`protected long`	`JAbstractAnalyser.estimateExecutionTime(NVector[] in)` Estimates the execution time based on the input data.
`long`	`JAbstractAnalyser.estimateExecutionTime(NVector[] in, Analyser anal)` Estimates the execution time based on the input data.
`long`	`DataAnalysing.estimateExecutionTime(NVector[] in, Analyser fit)` Estimates the execution time for a given analyser and input data.
`double`	`UserDrivenFitting.PeriodExtrema.evaluate(NVector freq)`
`double`	`UserDrivenFitting.PeriodError.evaluate(NVector freq)`
`protected double`	`CylindricalProjection.getX(NVector lamphi)` The standard cylindrical projection uses
`protected double`	`CylindricalEquidistantProjection.getX(NVector lamphi)` The standard cylindrical projection uses
`protected double`	`MercatorProjection.getY(NVector lamphi)` We calculate y from
`protected double`	`CylindricalProjection.getY(NVector lamphi)` This method is normally overriddn, as cylindric projection is a general term used for other projection with the same x, but different y transformation.
`protected double`	`CylindricalEquidistantProjection.getY(NVector lamphi)` We calculate y from
`protected double`	`CylindricalEqualAreaProjection.getY(NVector lamphi)` We calculate y from
`private void`	`JAnalyserToFit.newData(NVector[] old, NVector[] newdata)` Called when the analyser received new input data.
`private void`	`JAnalyserToFit.newData(NVector[] old, NVector[] newdata)` Called when the analyser received new input data.
`protected void`	`JVisualizingAnalyser.ready(NVector[] in, NVector[] out)` If we are ready, we further process the data to get the visualization.
`protected void`	`JVisualizingAnalyser.ready(NVector[] in, NVector[] out)` If we are ready, we further process the data to get the visualization.
`protected abstract void`	`JAsynchronAnalyser.ready(NVector[] pre, NVector[] processed)` This method is called, when the data has been processed in the analyser thread.
`protected abstract void`	`JAsynchronAnalyser.ready(NVector[] pre, NVector[] processed)` This method is called, when the data has been processed in the analyser thread.
`private boolean`	`JPhaseFrame.reanalyse(NVector[] in)` The analyser action.
`protected void`	`JStatisticAnalyser.setAnalyserInput(NVector[] in)` We change the numbers displayed on the button.
`protected void`	`JAbstractAnalyser.setAnalyserInput(NVector[] in)` This is the method that is called whenever the analyser input data is modified.
`Point2D`	`OrthographicTransformation.toNormalizedDistance(NVector ul, NVector dist)` Converts a ra/dec distance to a normalized distance.
`Point2D`	`JFitsCanvas.PixelCoordinate.toNormalizedDistance(NVector ul, NVector dist)` Converts a pixel distance to a normalized distance.
`Point2D`	`DeltaTransforming.toNormalizedDistance(NVector location, NVector delta)` Converts the user space distances in the second argument at the user space coordinate given in the second argument into distances in normalized coordinates.
`Point2D`	`CylindricalProjection.toNormalizedDistance(NVector location, NVector delta)` We call the `#toNormalized` twice and return the difference.
`Point2D`	`BasicTransform.toNormalizedDistance(NVector ignore, NVector delta)` In the this simple case, a delta transformation is simply scaled by the boxing rectangle size.
`Point2D`	`Transform2D.toNormalizedSpace(NVector twodim)` Converts a user coordinate into normalized coordinates.
`Point2D`	`SelectTransform.toNormalizedSpace(NVector xy)` We re-arrange the argument and call the super method.
`Point2D`	`OrthographicTransformation.toNormalizedSpace(NVector radec)` Converts a point from ra/dec into normalized pixel.
`Point2D`	`JFitsCanvas.PixelCoordinate.toNormalizedSpace(NVector user)` Converts user coordinates to normalized space.
`Point2D`	`DssTransformation.toNormalizedSpace(NVector radec)` Converts ra/dec into normalized coordinates.
`Point2D`	`CylindricalProjection.toNormalizedSpace(NVector lamphi)` Converts user space corrdinates, which are a longitude/latitude pair in degrees into x/y.
`Point2D`	`CoordinateTransforming.toNormalizedSpace(NVector user)` Converts a multi-dimensional input vector defined in a user-space coordinate system into the normalized screen coordinate system.
`Point2D`	`BasicTransform.toNormalizedSpace(NVector xy)` We map x/y into pixel coordinates, normalized to a top-left point 0,0 and a plottable size of 1x1.

Method parameters in jview with type arguments of type NVector
`private static NVector`	`JDataCanvas.getSpan(Collection<NVector> vec2d, boolean ad)` Takes a collection of 2d vectors and gets the minimum of x and y.
`int`	`JDataCanvas.putMeasuredSet(List<? extends NVector> points)` Sets a new list of data in the default color.
`int`	`JExpressionCanvas.putMeasuredSet(String setname, List<? extends NVector> points, List<Object> keys)` Sets a new list of data into the specified set.
`int`	`JDataCanvas.putMeasuredSet(String setname, List<? extends NVector> points, List<Object> keys)` Sets a new list of data into the specified set.
`int`	`JDataCanvas.putMeasuredSets(Map<String,List<? extends NVector>> pointmap, Map<String,List<Object>> keymap)` This methods allows setting of a bunch of user data, rescaling is only done at the very end if necessary.
`private boolean`	`JDataCanvas.putMeasurements(String setname, List<? extends NVector> points, List<Object> keys, boolean scale)` Sets a new list of data into the specified set.
`void`	`JExpressionFrame.setData(String setname, List<NVector> plot)` Sets the data that should be displayed in the frames expression canvas.

Constructors in jview with parameters of type NVector
`DssTransformation(Vector2D radec, Point2D plateoff, double arcsec, Vector2D micron, NVector rotmatrix, NVector platexsolution, NVector plateysolution)` Constructs a DssTransform with all neccessary parameters.
`JAsynchronAnalyser.AnalyserThread(ProgressMonitor boss, NVector[] input)` Prepares the analyser thread.

Uses of NVector in stella.adapter

Fields in stella.adapter declared as NVector
`private NVector`	`ModelShift.last` The last solution.
`private NVector`	`ModelDrift.last` The last solution.
`private NVector`	`ModelShift.PinholeModel.m0` A first estimate of the model parameters.
`private NVector`	`ModelDrift.PinholeDrift.m0` A first estimate of the model parameters.

Methods in stella.adapter that return NVector
`protected NVector`	`ModelShift.PinholeModel.getFirstModel()` Returns a first estimate.
`protected NVector`	`ModelDrift.PinholeDrift.getFirstModel()` Returns a first estimate.
`protected NVector`	`PyramidUnit.getPyramidLocation(List pyramid)` Fills in pyramid statistics from the four pyramid reflections.
`NVector[]`	`ModelShift.PinholeModel.getTimes()` Returns the evaluation points.
`NVector[]`	`ModelDrift.PinholeDrift.getTimes()` Returns the evaluation points.

Methods in stella.adapter with parameters of type NVector
`double`	`ModelShift.PinholeModel.evaluateModel(NVector dxdy, NVector xy)` Per definition, the independant variable, time, is here a two-dimensional vector specifying the location of the pixel.
`double`	`ModelDrift.PinholeDrift.evaluateModel(NVector dxdy, NVector xy)` Per definition, the independant variable, time, is here a two-dimensional vector specifying the location of the pixel.
`Matrix`	`ModelShift.PinholeModel.getGradientMatrix(NVector dxdy)` Returns the gradient matrix.
`Matrix`	`ModelDrift.PinholeDrift.getGradientMatrix(NVector dxdy)` Returns the gradient matrix.
`double[]`	`ModelShift.PinholeModel.getModel(NVector dxdy)` Per definition, the model data is a Vector of all data points, not an area.
`double[]`	`ModelDrift.PinholeDrift.getModel(NVector dxdy)` Per definition, the model data is a Vector of all data points, not an area.
`double[]`	`ModelShift.PinholeModel.getResiduals(NVector a)` Returns the residulas.
`double[]`	`ModelDrift.PinholeDrift.getResiduals(NVector a)` Returns the residulas.

Uses of NVector in stella.jview

Methods in stella.jview that return NVector
`private static NVector`	`JTrackingFrequencies.getPower(NVector data)` Zero-pads the data to both sides if necessary and does a simple power spectrum on it.
`private NVector`	`JEarthNight.getSolar(double phi, double h)` Returns a four-dimensional vector with four geographical longitudes.

Methods in stella.jview that return types with arguments of type NVector
`private List<NVector>`	`JTrackingFrequencies.convertToPlot(NVector power)` Adds a power-vector to this graph, on-the-fly transforming index in the vector to frequency in Hertz.

Methods in stella.jview with parameters of type NVector
`private List<NVector>`	`JTrackingFrequencies.convertToPlot(NVector power)` Adds a power-vector to this graph, on-the-fly transforming index in the vector to frequency in Hertz.
`private static NVector`	`JTrackingFrequencies.getPower(NVector data)` Zero-pads the data to both sides if necessary and does a simple power spectrum on it.
`private boolean`	`JObjectDisplay.residuals(List<DataCard> y, int sx, int sy, int se, NVector modpar, DataModel fit, JDataCanvas rms, String setname)`
`List`	`JTrackingFrequencies.setOffsetMeasures(String name, NVector data)` Sets the data set.

Uses of NVector in stella.math

Methods in stella.math that return NVector
`NVector`	`SphereTiles.getTile(int index)` Retruns the tile with the given index.

Methods in stella.math with parameters of type NVector
`private static boolean`	`SphereTiles.probeTile(NVector v, double az, double h)` Probes if a point on the sky lies within the tile specified by the 4-dimensional vector passed over.

Uses of NVector in stella.parameter

Fields in stella.parameter declared as NVector
`private static NVector`	`BarycentricVelocity.CCPAMV` CCPAMV = amdl/dt (planets)
`private NVector`	`FocusMeasure.extrafocal` The focus position to the fits moments, extrafocale.
`private NVector`	`FocusMeasure.infocus` The focus position to the fits moments, at estimated focus.
`private NVector`	`FocusMeasure.intrafocal` The focus position to the fits moments, intrafocale.

Methods in stella.parameter that return NVector
`private NVector`	`FocusMeasure.extractMoments(Value f, int order)` We calculate an exposure time from the light sensor.

Methods in stella.parameter with parameters of type NVector
`private static Double`	`FocusMeasure.getFocus(NVector in, NVector out, NVector here, double up)` Using the flat-field filter name and the fits moments, we estimate the best exposure time by using the average of the current fits compared to the target average in `#KEY_TARGETLEVEL`.

Uses of NVector in stella.telescope

Methods in stella.telescope that return types with arguments of type NVector
`private static Map<String,NVector>`	`TelescopeMaster.parsePointingList(String list)` We take a list of the Pilar pointing measure format and parse that into a lookup table linking pointing names (unique) to a four-dimensional vector, with az, azoff, z, zoff as its components.

Uses of NVector in stella.util

Fields in stella.util declared as NVector
`private NVector[]`	`GuiderMagnitudes.aircolor` The measurement points.
`private NVector`	`PointingModel.altboot` Average of the altitude solution in bootstrapping.
`private NVector`	`PointingModel.alterror` Errors of the altitude offset measurements or null if not available.
`private NVector`	`PointingModel.altmax` Maxima of the altitude solution in bootstrapping.
`private NVector`	`PointingModel.altmin` Minima of the altitude solution in bootstrapping.
`private NVector`	`PointingModel.altoffset` The zenith distance offsets measured.
`private NVector`	`PointingModel.altresiduals` Residuals of the altitude model.
`private NVector`	`PointingModel.altsigma` Sigma on the altitude solution, either covariance or bootstrap.
`private NVector`	`PointingModel.altsigorg` Covariance sigma in altitude parameters in bootstrapping.
`private NVector`	`PointingModel.altsolution` Solution of the altitude model, set with first call to `PointingModel.getAltitudeSolution()`.
`private NVector[]`	`PointingModel.azalt` The azimuth and zenith distance of the measurements, radian 0=az 1=z.
`private NVector`	`PointingModel.azboot` Average of the azimuth solution in bootstrapping.
`private NVector`	`PointingModel.azerror` Errors of the azimuth offset measurements or null if not available.
`private NVector`	`PointingModel.azmax` Maxima of the azimuth solution in bootstrapping.
`private NVector`	`PointingModel.azmin` Minima of the azimuth solution in bootstrapping.
`private NVector`	`PointingModel.azoffset` The azimuth offsets measured.
`private NVector`	`PointingModel.azresiduals` Residuals of the azimuth model.
`private NVector`	`PointingModel.azsigma` Sigma on the azimuth solution, either covariance or bootstrap.
`private NVector`	`PointingModel.azsigorg` Covariance sigma in azimuth parameters in bootstrapping.
`private NVector`	`PointingModel.azsolution` Solution of the azimuth model, set with first call to `PointingModel.getAzimuthSolution()`.
`private NVector`	`GuiderMagnitudes.dmag` The measurements, i.e.

Methods in stella.util that return NVector
`NVector`	`AuxiliaryPointing.evaluate(NVector nautz)` Retruns a Vector2D, x as azimuth, normally zero and y altitude pm, defined by the tube flexure.
`NVector`	`PointingFunction.ExtendedModel.evaluate(NVector nautz)` The classic pointing model expects the nautic azimuth in the first argument and the zenith distance in the second, both in degrees.
`NVector`	`PointingFunction.FullModel.evaluate(NVector nautz)` The classic pointing model expects the nautic azimuth in the first argument and the zenith distance in the second, both in degrees.
`NVector`	`PointingFunction.ClassicModel.evaluate(NVector nautz)` The classic pointing model expects the nautic azimuth in the first argument and the zenith distance in the second, both in degrees.
`NVector`	`PointingModel.getAltitudeSigma()` Returns the sigma of the altitude model.
`NVector`	`PointingModel.getAltitudeSolution()` Fits the offsets to the altitude model using linear regression.
`NVector`	`PointingModel.getAzimuthSigma()` Returns the sigma of the azimuth model.
`NVector`	`PointingModel.getAzimuthSolution()` Fits the offsets to the azimuth model using linear regression.
`private NVector`	`MirrorData.scanForBrightness(double ignore)` Scans for main stars and mirrors present.
`private NVector`	`MirrorData.scanForMirrors(double xmin, double xmax, double ymin, double ymax)` Scans for main stars and mirrors present.
`NVector`	`FocusSpindleFit.solve()` We try to solve for the spindle model.
`private NVector`	`GuiderMagnitudes.solve()` Solves for the zero point, the k and epsilon.

Methods in stella.util with parameters of type NVector
`private static void`	`PointingModel.FileData.addPM(NVector ap, NVector hp, NVector offa, NVector offh)` This adds pointing model offsets to raw data.
`private static void`	`PointingModel.FileData.dePoison(NVector ap, NVector hp, NVector offa, NVector offh)` Revert the pm-poisoned data to reflect azimuth and altitude on start.
`private Point2D`	`GuiderParametersRaDe.SimpleGnomic.deviation(NVector v, double ra, double de, double xpix, double ypix)`
`private static void`	`PointingModel.FileData.doRadian(NVector ap, NVector hp)` Revert the pm-poisoned data to reflect azimuth and altitude on start.
`double`	`GuiderParametersRaDe.SimpleGnomic.evaluate(NVector v)`
`double`	`FocusSpindleFit.AbstractPosition.evaluate(NVector params)` We evaluate the squared-distance sum.
`NVector`	`AuxiliaryPointing.evaluate(NVector nautz)` Retruns a Vector2D, x as azimuth, normally zero and y altitude pm, defined by the tube flexure.
`double`	`TelescopeError.evaluate(NVector pidvals)` Evaluate the PID.
`double`	`StarAmoeba.evaluate(NVector param)` Evaluates the amoeba.
`double`	`SineError.evaluate(NVector pidvals)` Evaluate the PID.
`NVector`	`PointingFunction.ExtendedModel.evaluate(NVector nautz)` The classic pointing model expects the nautic azimuth in the first argument and the zenith distance in the second, both in degrees.
`NVector`	`PointingFunction.FullModel.evaluate(NVector nautz)` The classic pointing model expects the nautic azimuth in the first argument and the zenith distance in the second, both in degrees.
`NVector`	`PointingFunction.ClassicModel.evaluate(NVector nautz)` The classic pointing model expects the nautic azimuth in the first argument and the zenith distance in the second, both in degrees.
`double`	`ImageAmoeba.evaluate(NVector param)` Evaluates the goodness of the supplied parameter.
`double`	`BeamSplitterFit.evaluate(NVector fit)` Evaluates the functional fit.
`double`	`GuiderParametersRaDe.SimpleGnomic.evaluate(NVector v, boolean print)`
`double`	`FocusSpindleFit.AbstractPosition.evaluate(NVector params, boolean print)` We evaluate the squared-distance sum.
`double`	`StarAmoeba.evaluate(NVector param, boolean printout)` Evaluates the amoeba.
`private double`	`BeamSplitterFit.evaluate(NVector fit, boolean print)` Evaluates the functional fit.
`private double`	`ImageAmoeba.evaluate(NVector param, boolean virgin, boolean update)` Evaluates the goodness of the supplied parameter.
`private double`	`StarAmoeba.getChi(Guiding.RawStar raw, NVector param)` Evaluates the chi on an inidividual detection.
`List<Point2D>`	`FocusSpindleFit.getModel(NVector solution)` Returns the model on the same focus positions as the measures.
`Point2D`	`FocusSpindleFit.PositionModel.getModelPoint(double f, NVector params)` This is the position as a point object returned by the model.
`Point2D`	`FocusSpindleFit.Drift.getModelPoint(double f, NVector params)` We evaluate the formular from above, using the pre-set values of the pixel and focus positions.
`Point2D`	`FocusSpindleFit.CorkScrew.getModelPoint(double f, NVector params)` We evaluate the formular from above, using the pre-set values of the pixel and focus positions.
`double[]`	`FocusSpindleFit.getResiduals(NVector solution)` Returns the distance between measurement and model in pixel.
`double`	`FocusSpindleFit.getRms(NVector solution)` Returns the rms of the fitted model to the model data.
`private static void`	`BeamSplitterFit.FitsFile.prettyPrint(NVector start, NVector end, Point center, double halfwidth, double halfheight, boolean hole)` Pretty printout.
`private static void`	`PointingModel.FileData.printSpectral(NVector ylm)` Prints spectral information on a harmonics solution by summing over all m's.
`void`	`PointingModel.setAltitude(NVector z)` Sets the zenith distance data.
`void`	`PointingModel.setAltitudeOffsets(NVector off, NVector err)` Sets the measured zenith distance offsets and the erros, if available.
`void`	`PointingModel.setAzimuth(NVector az)` Sets the azimuth data.
`void`	`PointingModel.setAzimuthEncoderOffsets(NVector off, NVector err)` Sets the azimuth data.
`void`	`PointingModel.setAzimuthOffsets(NVector off, NVector err)` Sets the measured azimuth offsets and the erros, if available.
`void`	`PointingModel.setZenithDistance(NVector z)` Sets the zenith distance data.
`void`	`PointingModel.setZenithOffsets(NVector off, NVector err)` Sets the measured zenith distance offsets and the erros, if available.
`void`	`PointingModel.subtractMean(NVector nv)` Replaces the measruements by the measurements minus their average

Uses of NVector in util

Fields in util declared as NVector
`private NVector[]`	`DataFileParser.post` The data post-processed.
`private NVector[]`	`DataFileParser.pre` The data as precessed by the analyser.
`private NVector[]`	`DataFileParser.set` The data.

Methods in util that return NVector

protected NVector[] DataFileParser.getData()
Returns the input data.

protected NVector[] DataFileParser.getLinearFit(NVector[] data, int column, int mesh)
Replaces a single data column with a spline fit of specified mesh-length.

protected NVector[] DataFileParser.getLinearFit(NVector[] data, int x, List<Integer> cols, int len)
Returns a new data array, where the specified columns are replaced with a natural cubic spline fit of the original data.

protected NVector[] DataFileParser.getProcessedData()
Returns the processed data.

protected NVector[] DataFileParser.getSplineFit(NVector[] data, int column, int mesh)
Replaces a single data column with a spline fit of specified mesh-length.

protected NVector[] DataFileParser.getSplineFit(NVector[] data, int x, List<Integer> cols, int len)
Returns a new data array, where the specified columns are replaced with a natural cubic spline fit of the original data.

protected NVector[] DataFileParser.getVisualizedData()
Returns the visualizable data.

protected NVector[] DataFileParser.getWhiteNoise(NVector[] data, int cc)
Replaces a single data column with white noise.

protected NVector[] DataFileParser.getWhiteNoise(NVector[] data, List<Integer> columns)
Returns a new data array, where the specified columns are replaced with white noise of the same average and sigma as the original data.

static NVector[] AsciiReader.parseVector(List<String> lines, Collection<Integer> columns)
Parses a list of lines into an array of NVectors.

static NVector[] AsciiReader.parseVector(List<String> lines, Map<Integer,? extends NumberFormat> format)
Parses a list of lines into an array of NVectors.

NVector ColumnCalculator.v841CenR(Map<String,Double> tdv)
The fit for V841Cen, sIRAIT campaign in July, 2007, Dome-C.

NVector ColumnCalculator.v841CenV(Map<String,Double> tdv)
The fit for V841Cen, sIRAIT campaign in July, 2007, Dome-C.

private static



<T extends Number> 


NVector[]

AsciiReader.vectorParsing(Collection<Integer> columns,
              Map<Integer,List<T>> col2vals)

Methods in util with parameters of type NVector
`protected NVector[]`	`DataFileParser.getLinearFit(NVector[] data, int column, int mesh)` Replaces a single data column with a spline fit of specified mesh-length.
`protected NVector[]`	`DataFileParser.getLinearFit(NVector[] data, int x, List<Integer> cols, int len)` Returns a new data array, where the specified columns are replaced with a natural cubic spline fit of the original data.
`protected NVector[]`	`DataFileParser.getSplineFit(NVector[] data, int column, int mesh)` Replaces a single data column with a spline fit of specified mesh-length.
`protected NVector[]`	`DataFileParser.getSplineFit(NVector[] data, int x, List<Integer> cols, int len)` Returns a new data array, where the specified columns are replaced with a natural cubic spline fit of the original data.
`protected NVector[]`	`DataFileParser.getWhiteNoise(NVector[] data, int cc)` Replaces a single data column with white noise.
`protected NVector[]`	`DataFileParser.getWhiteNoise(NVector[] data, List<Integer> columns)` Returns a new data array, where the specified columns are replaced with white noise of the same average and sigma as the original data.
`protected void`	`DataFileParser.print(NVector[] v, String head, int[] complex)` Prints a data set using the parsed settings.
`static void`	`DataFileParser.printOut(NumberFormat[] nf, PrintWriter out, NVector[] v, String head, int[] comp)` Prints an array of a multidimensional vector to the given print stream.
`static void`	`DataFileParser.printOut(PrintWriter out, NVector[] v, String head, int[] comp)` Prints an array of a multidimensional vector to the given print stream.
`protected boolean`	`DataFileParser.processData(NVector[] data)` Processes a single junk of data, provided as an array of `NVector` If parsed with `DataFileParser.process(java.lang.String[])`, 2dim and 3-dim data are arrays of `Vector2D` and `Vector3D`, respectively.
`protected boolean`	`DataFileParser.processSingleData(NVector[] workon)`
`private boolean`	`DataFileParser.splitDataSet(int ilo, int ihi, int splitnr, NVector[] data)` Splite a data set and processes the splitted set.

Uses of NVector in util.rmi

Methods in util.rmi that return NVector
`private static NVector`	`CallbackServerImpl.createRandom(int dim)` Creates a randomized NVector
`NVector`	`CallbackServerImpl.randomize(int dim)` The client calls this method, and the server returns a random number.
`NVector`	`CallbackServer.randomize(int dim)` The client calls this method, and the server returns a random number.

Methods in util.rmi with parameters of type NVector
`void`	`CallbackClientImpl.callback(NVector random)`
`void`	`CallbackClient.callback(NVector random)` The server call this method after registering.

Uses of NVector in vec_math

Subclasses of NVector in vec_math
`class`	`LineVector` A class that converts a string consiting of individual tokens into a NVector of doubles.
`class`	`polar2D` Extends the vector2D for capabilities to convert (x,y) into (r,phi).
`class`	`Vector1D` This class is the definition of a simple, one dimensional vector.
`class`	`vector2D` This class is the definition of a simple, two dimensional vector.
`class`	`Vector2D` This class is the definition of a simple, two dimensional vector.
`class`	`vector3D` This class is the definition of a simple, two dimensional vector.
`class`	`Vector3D` This class is the definition of a simple, three dimensional vector.

Fields in vec_math declared as NVector
`private NVector`	`Bootstrap.average` The parameter averages on the solution to the simulated data.
`private NVector[]`	`Matrix.col`
`private NVector`	`Bootstrap.confidence` The confidence estimations on the solution to the original data.
`private NVector[]`	`ExpressionFit.AmoebaModel.data` Input data, on each NVector only zero and yindex is used.
`private NVector`	`Bootstrap.data` The original data.
`private NVector[]`	`Bootstrap.depend` Where/how we measured the data.
`private NVector`	`Bootstrap.ExchangedData.err` Measurement errors, might be null.
`private NVector`	`Bootstrap.ExchangedData.errdrop` These data is those dropped from the original set, meas errs.
`private NVector`	`Bootstrap.error` The errors of the original data.
`private NVector`	`Amoeba.fout` On output, the evaluation of `Amoeba.f` at points `#out`.
`private NVector`	`GeneralLinearRegression.linfit` The fitted parameters.
`private NVector`	`Bootstrap.maxima` The parameter maxima on the solution to the simulated data.
`private NVector`	`Bootstrap.minima` The parameter minima on the solution to the simulated data.
`private NVector`	`GeneralLinearRegression.modelfit` The model fit to the data.
`private NVector[]`	`Amoeba.p` An n+1-dimensional set of starting points.
`private NVector[]`	`Amoeba.pout` On output, the n+1 points lying within `Amoeba.tolerance` around min.
`private NVector[]`	`Matrix.row` The vectors defining the rows of the matrix.
`private NVector`	`GeneralLinearRegression.si` The errors of the measurements or null if unknown.
`private NVector`	`GeneralLinearRegression.sigfit` The standard deviations of the fitted parameters.
`private NVector[]`	`Bootstrap.ExchangedData.x` The values of the dependables where y was measured.
`protected NVector[]`	`AbstractDataModel.x` The independant variables as an array of vectors.
`private NVector[]`	`Bootstrap.ExchangedData.xdrop` These data is those dropped from the original set, dependent x.
`private NVector`	`Bootstrap.ExchangedData.y` The measured values.
`private NVector`	`Bootstrap.ExchangedData.ydrop` These data is those dropped from the original set, measures.
`private NVector`	`GeneralLinearRegression.yi` The measurements, corresponding to the rows of the design matrix.

Fields in vec_math with type parameters of type NVector
`private List<NVector>`	`MultipleFrequencyFit.valid` The solutions, ordered for increasing order in the series.
`private List<NVector>`	`LeastFourier.valid` The solutions, ordered for increasing order in the series.

Methods in vec_math with type parameters of type NVector

static



<T extends NVector> 


T[]

NVector.sort(T[] unsorted,
     int index)

Data must be sorted according to given indices values.

Methods in vec_math that return NVector

static NVector NVector.add(NVector s1, NVector s2, NVector dest)
Returns the addition of two vectors with equal dimension.

static NVector GeneralLinearRegression.convert(NVector[] in, int index)
For convenience to shift between different data formats.

private static NVector[] CleanFourier.dirty(NVector[] data, double stretch, double fmax, double over)
Calculates the discrete FT of the data and of the window.

static NVector[] NVector.doubleParse(String doubletokenize)
Double-tokenizes a string such that the input is split on the semicolon (actually the OUTERLIST separator of StringTool) and each of these splits is used to parse a single vector out of it.

NVector VectorFunction.evaluate(NVector x)
Evaluates an NVector of dimension VectorFunction.argumentDimension() to an NVector of dimension VectorFunction.functionDimension().

private static NVector Matrix.extract(NVector[] vector, int n)
Extracts a row/column from a column/row representation of a matrix.

static NVector[] AbstractAnalyser.getBootstrapData(NVector[] in)
Returns a bootstrapped data set from the original data with a default duplication rate of 1/e.

static NVector[] AbstractAnalyser.getBootstrapData(NVector[] in, double fraction)
Returns a bootstrapped data set from the original data.

NVector Amoeba.getClosestPoint()
On successful crawls, this method returns the point closest to the function minimum.

NVector Matrix.getColumn(int m)
Returns the specified column as an nvector.

NVector Bootstrap.getConfidenceEstimates()
Returns a confidence estimate on the linear model parameter by bootstrapping the data.

static NVector[] AbstractAnalyser.getDiminishedData(NVector[] in)
Returns a diminished data set from the original data with a default drop-out rate of 1/e.

static NVector[] AbstractAnalyser.getDiminishedData(NVector[] in, double fraction)
For analysers that cannot deal with identical points, we can drop a random fraction of the original data, making the resulting data set smaller.

NVector Bootstrap.ExchangedData.getDroppedErr()
Returns the errors dropped from the original set or null if unspecified.

NVector[] Bootstrap.ExchangedData.getDroppedX()
Returns the dependables dropped from the original set.

NVector Bootstrap.ExchangedData.getDroppedY()
Returns the measurements dropped from the original set.

NVector Bootstrap.ExchangedData.getErr()
Returns the errors or null if unspecified.

NVector GeneralLinearRegression.getModelFit()
Returns the model fit to the data.

NVector[] ModelSource.getModelInput()
This method delivers data that should be analysed in an model fitting ModelFitting.fit() method.

static NVector AbstractFit.getModelParameterErrors(List<Variable> p)
Converts a list of model parameters into an nvector of its values.

static NVector AbstractFit.getModelParameterValues(List<Variable> p)
Converts a list of model parameters into an nvector of its values.

static NVector AbstractGradientModel.getNegativeChi2HalfGradient(GradientModel grad, NVector a)
Returns half the negativ gradient of chi-square of this model with respect to the model parameters.

NVector AbstractGradientModel.getNegativeChi2HalfGradient(NVector a)
Returns half the negativ gradient of chi-square of this model with respect to the model parameters.

NVector Bootstrap.getOriginalSigma()
Returns the standard diviation to the original solution.

NVector Bootstrap.getOriginalSolution()
Returns the orignal solution to the linear model.

protected NVector Matrix.getRawColumn(int m)
Always return the column, even if not valid.

protected NVector Matrix.getRawRow(int n)
Always return the specified row, even if invalid.

NVector GeneralLinearRegression.getResiduals()
Returns the residuals.

NVector Matrix.getRow(int n)
Returns the specified row as an nvector.

NVector GeneralLinearRegression.getSigma()
Returns the vector of the standard deviations of the linear fit parameters.

NVector[] Amoeba.getSimplex()
On successful crawls, this method returns the last points of the simplex.

NVector Amoeba.getSimplexValue()
On successful crawls, this method returns the last function evaluations at the simplex's points, see Amoeba.getSimplex().

NVector Bootstrap.getSimulatedMaxima()
Returns the maximas on the linear model parameter from bootstrapping the data.

NVector Bootstrap.getSimulatedMinima()
Returns the minimas on the linear model parameter from bootstrapping the data.

NVector Bootstrap.getSimulatedSolution()
Returns the averages on the linear model parameter from bootstrapping the data.

NVector GeneralLinearRegression.getSolution()
Returns the vector of the solving linear parameters that minimize chi^2 Sets the LinFit array and validFit.

NVector StatisticAnalyser.getStatistic(int index)
Returns the average of the data, the standard deviation, skewness and kurtoises.

private NVector Amoeba.getSum(NVector[] calc)
Evaluates the sum of a vector array.

NVector[] ExpressionFit.AmoebaModel.getTimes()
Returns the times, this is an array of 1-d vectors initialized to data[].0.

NVector[] DataModel.getTimes()
Returns the 'times' of the measurements ('x') as an array of vectors.

NVector[] AbstractDataModel.getTimes()
Returns the times the measurements were taken.

NVector[] Bootstrap.ExchangedData.getX()
Returns the dependables.

NVector Bootstrap.ExchangedData.getY()
Returns the measurements.

NVector Gradient.grad(NVector at)
Returns the gradient vector at the given point.

NVector VectorDifferentiable.gradient(int[] i, NVector x)
Returns the evaluation of the gradient of the function in carthesian coordinates.

NVector LevenbergMarquardt.improve(NVector start)
Iterates for a solution to the data model, starting from the given start vector.

private NVector MultipleFrequencyFit.improve(NVector[] in, List<NVector> freqs, int[] fixorder)
Improvement of multidimensional fourier fit means we take a vector of frequencies and amplitudes, construct single-order fourier series out of them and let all frequencies and amplitudes varry, except those stated in the fixed orders array.

static NVector Math2.interpolatingParabel(NVector a1, NVector a2, NVector a3, double xd)
Parabolic interpolation.

NVector Phasing.PhaseMultidimensional.invert(double phi)
On vector invert, we return all vector elements zero except the index one.

NVector MultidimensionalInverse.invert(double y)
Calculates the argument vector.

static NVector AbstractGradientModel.LevenbergMarquardtSolver(GradientModel exp, NVector start)
We use a LevenbergMarquardt in standard form to solve for a minimum model.

static NVector AbstractDataModel.LorentzianSolver(DataModel exp, NVector start, NVector length)
We use a Simplex in robust form to solve for a minimum model.

static NVector NVector.multiply(double lambda, NVector s1, NVector dest)
Multiplies this vector with a scalar.

static NVector VectorRoot.newton(NVector start, VectorDifferentiable f)
Does a multidimensional root-finding of the VectorDifferentiable stated.

static NVector VectorRoot.newton(NVector start, VectorDifferentiable f, int maxiter)
Does a multidimensional root-finding of the VectorDifferentiable stated.

static NVector VectorRoot.newton(NVector start, VectorDifferentiable f, int maxiter, double maxoff, double maxstep)
Does a multidimensional root-finding of the VectorDifferentiable stated.

static NVector NVector.parse(String comma)
Parses an NVector from a comma-sparated list of doubles.

static NVector PowerSpectrum.periodogram(NVector data, int m, int k, Function window)
Does a periodogram of equally sampled data points.

NVector[] StatisticAnalyser.process(NVector[] in)
Calls the processing on all indices.

NVector[] PhaseDispersionMinimization.process(NVector[] data)
Calls the processing as phase-dispersion minimization.

NVector[] MultipleFrequencyFit.process(NVector[] in)
Processes the data until we reach either MultipleFrequencyFit.KEY_ORDER in the Fouriere series expansion, or the frequency is stable to MultipleFrequencyFit.KEY_CONVERGENCE.

NVector[] MinimumStringLength.process(NVector[] data)
Calls the processing as phase-dispersion minimization.

NVector[] LeastFourier.process(NVector[] in)
Processes the data until we reach either LeastFourier.KEY_ORDER in the Fouriere series expansion, or the frequency is stable to LeastFourier.KEY_CONVERGENCE.

NVector[] Fourier.process(NVector[] in)
Calls the Fourier Transform.

NVector[] Analyser.process(NVector[] in)
Takes a set of input data and transforms it into a set of output data.

static NVector AbstractDataModel.RobustSolver(DataModel exp, NVector start, NVector length)
We use a Simplex in robust form to solve for a minimum model.

private static NVector[] PhaseRegression.PhaseModel.shovel(NVector t)
Converts a NVector into a Vector1D[]

static NVector PowerSpectrum.simple(NVector data, Function window)
Simple periodogramm with no error estimates.

static NVector AbstractDataModel.SimplexSolver(DataModel exp, NVector start, NVector length)
We use a Simplex in standard form to solve for a minimum model.

NVector QuadMatrix.solve(NVector rhs)
Solves the system of linear equations represented by this quadmatrix for the system

static NVector QuadMatrix.solve(QuadMatrix q, NVector rhs)
Solves the system of linear equations represented by this quadmatrix for the system

static



<T extends NVector> 


T[]

NVector.sort(T[] unsorted,
     int index)

Data must be sorted according to given indices values.

static NVector NVector.subtract(NVector s1, NVector s2, NVector dest)
Returns the subtraction of two vectors with equal dimension.

NVector[] StatisticAnalyser.visualize(NVector[] in, NVector[] v)
Data is already reduced to minimum.

NVector[] MultipleFrequencyFit.visualize(NVector[] in, NVector[] allfits)
Visualized data is the original data minus the highest-order Fourier fit.

NVector[] LeastFourier.visualize(NVector[] in, NVector[] allfits)
Visualized data is the original data minus the highest-order Fourier fit.

NVector[] Fourier.visualize(NVector[] in, NVector[] ft)
Calls the periodogram.

NVector[] Analyser.visualize(NVector[] in, NVector[] processed)
Further transforms the processed vector into some visualizable vector.

NVector[] AbstractAnalyser.visualize(NVector[] in, NVector[] out)
Default implementation of visualization returns just the output data.

Methods in vec_math with parameters of type NVector

static NVector NVector.add(NVector s1, NVector s2, NVector dest)
Returns the addition of two vectors with equal dimension.

void StatisticAnalyser.addValue(NVector data)
Adds a data point to the statistic with the given index.

private double Amoeba.amotry(NVector[] base, NVector val, NVector psum, int ih, double direction)
An ugly method that extrapolates through the face of the simplex from the highest point.

private static double[] CleanFourier.beam(NVector[] dft)
Fits a clean beam to the window function by fitting a real Gaussian with beam(0)=1 to the window.

static void AbstractGradientModel.check(AbstractGradientModel fit, NVector exact)
Check the gradient matrix with the exact solution.

static void AbstractGradientModel.check(AbstractGradientModel fit, NVector exact, double da)
Check the gradient matrix with the exact solution.

private static Vector2D[] CleanFourier.clean(NVector[] dirty, double gain, int nmax, double resmax, double cmin)
Calculates the cleaned DFT of the dirty DFT recursively.

int NVector.IComp.compare(NVector n1, NVector n2)
Compares two NVector using the specified index.

static CentralMoments CentralMoments.constructVectorMoments(int k, NVector v)
Constructs a new statistic from a NVector.

static Moments Moments.constructVectorMoments(int k, NVector v)
Constructs a new statistic from a NVector.

private static Vector2D[] CubicSpline.convert(NVector[] two)
Converts an array of NVectors into an array of Vector2D or throws an exception, if a single non-two dimensional vector was found.

static NVector GeneralLinearRegression.convert(NVector[] in, int index)
For convenience to shift between different data formats.

void StatisticAnalyser.deleteValue(NVector data)
Removes a data point to the statistic with the given index.

protected Matrix GeneralLinearRegression.deriveDesignMatrix(Function[] base, NVector xi)
Calculates the design matrix from the basic functions and the measurement times.

protected Matrix GeneralLinearRegression.deriveDesignMatrix(Multidimensional[] base, NVector[] xi)
Calculates the design matrix from the basic functions and the measurement dependables.

private Matrix GeneralLinearRegression.deriveMeasureMatrix(Matrix desmat, NVector y, NVector sig)
Sets the measure Matrix out of yi,si and design.

static Matrix NVector.direct(NVector a, NVector b)
Returns the direct product of this vector with the argumental vector.

private static NVector[] CleanFourier.dirty(NVector[] data, double stretch, double fmax, double over)
Calculates the discrete FT of the data and of the window.

private static Vector2D PhaseDispersionMinimization.dispersion(NVector[] sorted, double period, int[] bins, double norm)
Calculates a single theta value for a given period.

static double NVector.dot(NVector a, NVector b)
Returns the scalar product of this vector with the target vector.

void ExpressionFit.estimateStart(NVector start, double ls)
Estimates the start for the amoeba.

void Amoeba.estimateStart(NVector single, double scale)
Tries to estimate a starting simplex from a single start point.

void ExpressionFit.estimateStart(NVector start, NVector ls)
Estimates the start for the amoeba.

void Amoeba.estimateStart(NVector single, NVector scale)
Tries to estimate a starting simplex from a single start point.

NVector VectorFunction.evaluate(NVector x)
Evaluates an NVector of dimension VectorFunction.argumentDimension() to an NVector of dimension VectorFunction.functionDimension().

double Phasing.PhaseMultidimensional.evaluate(NVector d1)
We act on the specified index.

double Multidimensional.evaluate(NVector x)
Evaluates this function at an input vector x.

double Fourier.Series.evaluate(NVector fanbn)
Evaluates a fourier series with the given set of coefficents and frequency.

double ExpressionMultidimensional.evaluate(NVector x)
The expression is checked for the occurence of the variable.

double AbstractDataModel.LocalM.evaluate(NVector a)
We evaluate

double PrintMultidimensional.evaluate(NVector x, boolean print)
Evaluates this function at an input vector x.

double HarmonicFit.HarmonicModel.evaluateModel(NVector tup4, NVector x1)
The model parameters are per index 0: frequency f = 1/P; ω=2πf 1: cosine amplitude 2: sine amplitude 3: constant offset

double PhaseRegression.PhaseModel.evaluateModel(NVector amp, NVector t)
We convert the model vector into a.0+a.1*cos(2pi/P*(t.0-a.2))

double MultipleFrequencyFit.FourierComponents.evaluateModel(NVector tup3, NVector x1)

double LevenbergMarquardt.SinusModel.evaluateModel(NVector a, NVector t)

double LevenbergMarquardt.LMSineModel.evaluateModel(NVector a, NVector t)

double ExpressionFit.AmoebaModel.evaluateModel(NVector a, NVector time)
Returns the model at a single point.

double DataModel.evaluateModel(NVector parameters, NVector t)
Evaluates the data model on a single point in the independant parameter space, normally the time.

private static NVector Matrix.extract(NVector[] vector, int n)
Extracts a row/column from a column/row representation of a matrix.

private static int SmoothParabola.extremum(NVector[] data, int index, double sign, int from, int to)
Searches an extremum.

static List<Extremum> SmoothParabola.findExtrema(NVector[] data, int index)
Scans the entire array for all local minima and maxima, which are returned as a list of Extremums.

private static double Bootstrap.fitDropped(Object[] fitting, NVector solution, NVector[] x, NVector y)
Fits a data set in y contained in the dependant variables x to the linear model parameters in solution.

protected Vector3D[] LombPeriodogram.fourierTransform(NVector[] data)
The fourier is done with lomb periodogrtam.

protected abstract Vector3D[] Fourier.fourierTransform(NVector[] data)
Does a fourier transfrom in the sense that:
Let f(t) be a real function sampled at t_j to give a set of f_j.
The discrete fourier transform is defined as the complex

protected Vector3D[] CleanFourier.fourierTransform(NVector[] data)
The fourier is done with clean periodogram.

long[] StatisticAnalyser.functionCalls(NVector[] in)
We call only basic functions.

long[] PhaseDispersionMinimization.functionCalls(NVector[] data)
Only plain arithmetics.

long[] MultipleFrequencyFit.functionCalls(NVector[] in)
No estimate possible.

long[] MinimumStringLength.functionCalls(NVector[] data)
Only plain arithmetics and roots.

long[] LombPeriodogram.functionCalls(NVector[] in)
We call sin/cos and sqrt.

long[] LeastFourier.functionCalls(NVector[] in)
No estimate possible.

long[] CleanFourier.functionCalls(NVector[] data)
We call sin/cos and exp.

long[] Analyser.functionCalls(NVector[] in)
Returns an estimate of the number of mathematical functions called.

static NVector[] AbstractAnalyser.getBootstrapData(NVector[] in)
Returns a bootstrapped data set from the original data with a default duplication rate of 1/e.

static NVector[] AbstractAnalyser.getBootstrapData(NVector[] in, double fraction)
Returns a bootstrapped data set from the original data.

static Vector3D[] CleanFourier.getClean(NVector[] data)
Returns a cleaned spectrum.

static Vector3D[] CleanFourier.getClean(NVector[] data, double stretch, double fmax, double over)
Returns a cleaned spectrum.

static Vector3D[] CleanFourier.getClean(NVector[] data, double stretch, double fmax, double over, double gain, int nmax, double rmax, double cmin)
Returns a cleaned spectrum.

static NVector[] AbstractAnalyser.getDiminishedData(NVector[] in)
Returns a diminished data set from the original data with a default drop-out rate of 1/e.

private static Bootstrap.ExchangedData Bootstrap.getExchangedData(NVector[] depend, NVector data, NVector err, double duplicate)
From our measurements and theier errors we derive a simulated data set.

static Vector3D[] LombPeriodogram.getFourier(NVector[] data)
Calculates the Lomb normalized periodogram on a data set given as x/y pairs in the input vector with default oversampling and Nyquist multiples.

static Vector3D[] LombPeriodogram.getFourier(NVector[] data, double span, double fmax, double over)
Calculates the Lomb non-normalized periodogram on a data set given as x/y pairs in the input vector.

Matrix HarmonicFit.HarmonicModel.getGradientMatrix(NVector tup4)
The gradient matrix of the model holds per column index 0: d/df frequency f = 1/P; ω=2πf.

Matrix MultipleFrequencyFit.FourierComponents.getGradientMatrix(NVector tup3)

Matrix LevenbergMarquardt.SinusModel.getGradientMatrix(NVector a)

Matrix LevenbergMarquardt.LMSineModel.getGradientMatrix(NVector a)

Matrix GradientModel.getGradientMatrix(NVector parameters)
Returns the gradient of the model for all measures.

Matrix AbstractVectorDifferentiable.getJacobian(NVector at)
Gets the Jacobian matrix of this vector differentiable.

static Matrix AbstractVectorDifferentiable.getJacobian(VectorDifferentiable f, NVector at)
Gets the Jacobian matrix of this vector differentiable.

static double Fourier.getMaximumSpan(NVector[] sorted)
Returns the time-span of the observation, data must be sorted.

static double Fourier.getMinimumStep(NVector[] sorted)
Calculates the minimum time step in the data.

double[] PhaseRegression.PhaseModel.getModel(NVector amp)
We convert the model vector into a.0+a.1*cos(2pi/P*(t-a.2))

double[] ExpressionFit.AmoebaModel.getModel(NVector a)
The model

double[] DataModel.getModel(NVector parameters)
Returns model data for the given set of model parameters.

double[] AbstractDataModel.getModel(NVector a)
Returns the entire model by stepping through all measurement times.

static double[] AbstractDataModel.getModel(NVector a, DataModel dm)
Static version.

private double[] ExpressionFit.AmoebaModel.getModelAtData(NVector a)
Returns the current model fit at all data points.

static NVector AbstractGradientModel.getNegativeChi2HalfGradient(GradientModel grad, NVector a)
Returns half the negativ gradient of chi-square of this model with respect to the model parameters.

NVector AbstractGradientModel.getNegativeChi2HalfGradient(NVector a)
Returns half the negativ gradient of chi-square of this model with respect to the model parameters.

static Vector2D[] LombPeriodogram.getPeriodogram(NVector[] data)
Calculates the Lomb normalized periodogram on a data set given as x/y pairs in the input vector with default oversampling and Nyquist multiples.

static Vector2D[] CleanFourier.getPeriodogram(NVector[] data)
Returns a periodogram.

static Vector2D[] LombPeriodogram.getPeriodogram(NVector[] data, double span, double fmax, double over)
Calculates the Lomb normalized periodogram on a data set given as x/y pairs in the input vector with default oversampling and Nyquist multiples.

static Vector2D[] CleanFourier.getPeriodogram(NVector[] data, double stretch, double fmax, double over)
Returns a periodogram.

static Vector2D[] CleanFourier.getPeriodogram(NVector[] data, double stretch, double fmax, double over, double gain, int nmax, double rmax, double cmin)
Returns a periodogram.

static QuadMatrix AbstractGradientModel.getPseudoHessian(GradientModel grad, NVector a)
Returns the pseudo-hessian matrix consiting of the first derivatives only for the given set of parameters.

QuadMatrix AbstractGradientModel.getPseudoHessian(NVector a)
Returns the pseudo-hessian matrix consiting of the first derivatives only for the given set of parameters.

double[] ExpressionFit.AmoebaModel.getResiduals(NVector a)
Returns the residuals of the measures to the data model.

double[] DataModel.getResiduals(NVector a)
Returns the residuals of the measures to the data model.

double[] AbstractDataModel.getResiduals(NVector a)
Returns the residuals of the measures to the data model.

static double[] AbstractDataModel.getResiduals(NVector a, DataModel dm)
Returns the residuals of the measures to the data model.

static double AbstractDataModel.getRms(NVector a, DataModel dm)
Return the rott of the average of the residuals squared.

private NVector Amoeba.getSum(NVector[] calc)
Evaluates the sum of a vector array.

NVector Gradient.grad(NVector at)
Returns the gradient vector at the given point.

NVector VectorDifferentiable.gradient(int[] i, NVector x)
Returns the evaluation of the gradient of the function in carthesian coordinates.

static GeneralLinearRegression GeneralLinearRegression.harmonic(NVector t, NVector y, NVector sigma, double omega)
Creates an offset sine/cosine wave to the data.

NVector LevenbergMarquardt.improve(NVector start)
Iterates for a solution to the data model, starting from the given start vector.

static NVector Math2.interpolatingParabel(NVector a1, NVector a2, NVector a3, double xd)
Parabolic interpolation.

private QuadMatrix GeneralLinearRegression.invertNormal(Matrix desm, NVector sig)
Inverts the normal equations (A(T)A), therefore the design matrix must be valid.

static NVector AbstractGradientModel.LevenbergMarquardtSolver(GradientModel exp, NVector start)
We use a LevenbergMarquardt in standard form to solve for a minimum model.

static GeneralLinearRegression GeneralLinearRegression.line(NVector x, NVector y, NVector sigma)
Creates a general lineare regression that is a fit to a straight line.

static NVector AbstractDataModel.LorentzianSolver(DataModel exp, NVector start, NVector length)
We use a Simplex in robust form to solve for a minimum model.

static int SmoothParabola.maximum(NVector[] data, int index)
Searches a global maximum.

static int SmoothParabola.maximum(NVector[] data, int index, int from, int to)
Searches a global maximum.

Object[] StatisticAnalyser.metadata(NVector[] in, NVector[] proc, NVector[] visual)
Minimum string length analysis have no metadata.

Object[] PhaseDispersionMinimization.metadata(NVector[] in, NVector[] proc, NVector[] visual)
Phase dispersion minimization analysis have no metadata.

Object[] MultipleFrequencyFit.metadata(NVector[] in, NVector[] allfits, NVector[] p)
Metadata are the fitting Fouries with their false alarm probabilities.

Object[] MinimumStringLength.metadata(NVector[] in, NVector[] proc, NVector[] visual)
Minimum string length analysis have no metadata.

Object[] LeastFourier.metadata(NVector[] in, NVector[] allfits, NVector[] p)
Metadata are the fitting Fouries plus RMS in the following sense.

Object[] Fourier.metadata(NVector[] in, NVector[] proc, NVector[] visual)
Fourier analysis have no metadata.

Object[] Analyser.metadata(NVector[] in, NVector[] proc, NVector[] visual)
After processing, the analyser may be able to provide some metadata.

static int SmoothParabola.minimum(NVector[] data, int index)
Searches a global minimum.

static int SmoothParabola.minimum(NVector[] data, int index, int from, int to)
Searches a global minimum.

static Vector2D[] MinimumStringLength.msl(NVector[] data)
Calculates the Theta-array for a given t vs.

static Vector2D[] MinimumStringLength.msl(NVector[] unscaled, double pmin, double pmax)
Calculates the Theta-array for a given t vs.

static Vector2D[] MinimumStringLength.msl(NVector[] unscaled, double pmin, double pmax, int fnum)
Calculates the Theta-array for a given t vs.

static NVector NVector.multiply(double lambda, NVector s1, NVector dest)
Multiplies this vector with a scalar.

static NVector VectorRoot.newton(NVector start, VectorDifferentiable f)
Does a multidimensional root-finding of the VectorDifferentiable stated.

static NVector VectorRoot.newton(NVector start, VectorDifferentiable f, int maxiter)
Does a multidimensional root-finding of the VectorDifferentiable stated.

static NVector VectorRoot.newton(NVector start, VectorDifferentiable f, int maxiter, double maxoff, double maxstep)
Does a multidimensional root-finding of the VectorDifferentiable stated.

static GeneralLinearRegression GeneralLinearRegression.parabola(NVector x, NVector y, NVector sigma)
Creates a general lineare regression that is a fit to a parabola.

static Vector2D[] PhaseDispersionMinimization.pdm(NVector[] data)
Calculates the Theta-array for a given t vs.

static Vector2D[] PhaseDispersionMinimization.pdm(NVector[] sorted, double pmin, double pmax)
Calculates the Theta-array for a given t vs.

static Vector2D[] PhaseDispersionMinimization.pdm(NVector[] sorted, double norm, double pmin, double pmax, int fnum, int[] bin)
Calculates the Theta-array for a given t vs.

static Vector2D[] PhaseDispersionMinimization.pdm(NVector[] sorted, double pmin, double pmax, int fnum)
Calculates the Theta-array for a given t vs.

static Vector2D[] PhaseDispersionMinimization.pdm(NVector[] sorted, double pmin, double pmax, int fnum, int[] bin)
Calculates the Theta-array for a given t vs.

static NVector PowerSpectrum.periodogram(NVector data, int m, int k, Function window)
Does a periodogram of equally sampled data points.

static GeneralLinearRegression GeneralLinearRegression.polynomial(int order, NVector x, NVector y, NVector sigma)
Creates a general lineare regression that is a fit to a polynominal of certain order.

DataModel HarmonicFit.prepareFit(NVector[] in)
Visualization means performing a linear Regression using GeneralRegression#harmonic.

DataModel PhaseRegression.prepareFit(NVector[] in)
Visualization means performing a linear Regression using GeneralRegression#harmonic.

DataModel ModelFitting.prepareFit(NVector[] data)
Initializing the fitting process by preparing the underlying data model.

DataModel ExpressionFit.prepareFit(NVector[] data)
The data is processed by slowly fitting the amoeba to a minimum.

private static GeneralLinearRegression Bootstrap.prepareRegression(Object[] fitting, NVector[] x, NVector y, NVector err)
Prepares a GeneralLinearRegression from the funtions, dependables and measurements passed over.

protected void LeastFourier.FourierAmoeba.previousFit(NVector old)
We estimate a first solution by calculating remainder of the fit minus the last fit, which has a handle for amplitude estimation.

private String ExpressionFit.AmoebaModel.printModel(NVector a)
We convert the expression parsed for printing, and during evaluate.

NVector[] StatisticAnalyser.process(NVector[] in)
Calls the processing on all indices.

NVector[] PhaseDispersionMinimization.process(NVector[] data)
Calls the processing as phase-dispersion minimization.

NVector[] MinimumStringLength.process(NVector[] data)
Calls the processing as phase-dispersion minimization.

NVector[] Fourier.process(NVector[] in)
Calls the Fourier Transform.

NVector[] Analyser.process(NVector[] in)
Takes a set of input data and transforms it into a set of output data.

protected boolean Fourier.AbstractFile.processData(NVector[] arg)
Process the switches.

protected boolean CleanFourier.File.processData(NVector[] arg)
Process the switches.

Point2D Projection.project(NVector data)
Converts an n-dimensional input data into a point.

private static Vector3D[] CleanFourier.pure(NVector[] residual, Vector2D[] clear, double[] beam)
Reconstruct the clean spectrum by convolving the clean component with a beam function and add the last dirty DFT of the data, which is the residual after CleanFourier.clean(vec_math.NVector[], double, int, double, double).

static NVector AbstractDataModel.RobustSolver(DataModel exp, NVector start, NVector length)
We use a Simplex in robust form to solve for a minimum model.

static int NVector.search(NVector[] sorted, int index, double max)
Returns the integer such that

static int[] NVector.searchMinMax(NVector[] data, int coor)
Returns the index of the minimum and maximum vector component in the specified array.

boolean GeneralLinearRegression.setBasicFunctions(Function[] fitting, NVector t)
Daugther classes must interfere here.

boolean GeneralLinearRegression.setBasicFunctions(Multidimensional[] fitting, NVector[] t)
Daugther classes must interfere here.

void Matrix.setCols(NVector[] newcol)
Same restrictions as in setRows.

void GeneralLinearRegression.setMeasurements(NVector meas, NVector error)
Sets the measurement vector.

protected boolean ExpressionFit.AmoebaModel.setModelData(NVector[] matrix)
Sets the model data and the model index.

protected void Matrix.setOneCol(int m, NVector newcol)
Same restrictions as in setOneRow.

protected boolean Matrix.setOneRow(int n, NVector newrow)
Changes only one row, specified by it's number n.

void Matrix.setRows(NVector[] newrow)
Sets the matrix via its row-like representation.

void Amoeba.setStart(NVector[] start)
Sets the starting simplex.

private static NVector[] PhaseRegression.PhaseModel.shovel(NVector t)
Converts a NVector into a Vector1D[]

double StatisticAnalyser.significance(double theta, NVector[] data, NVector[] p, NVector[] v)
Estimates the significance of a theta value by simple means of chi-square thesis.

double PhaseDispersionMinimization.significance(double theta, NVector[] data, NVector[] p, NVector[] v)
Estimates the significance of a theta value by simple means of chi-square thesis.

double MultipleFrequencyFit.significance(double f, NVector[] data, NVector[] fit, NVector[] residual)
No significance yet.

double MinimumStringLength.significance(double theta, NVector[] data, NVector[] p, NVector[] v)
Estimates the significance of a theta value by simple means of chi-square thesis.

double LeastFourier.significance(double f, NVector[] data, NVector[] fit, NVector[] residual)
No significance yet.

double Fourier.significance(double pdf, NVector[] data, NVector[] p, NVector[] v)
Significance out of false-alarm.

double Analyser.significance(double check, NVector[] in, NVector[] processed, NVector[] visual)
If the analysier can produce something like a significance of a value, this is returned here.

static NVector PowerSpectrum.simple(NVector data, Function window)
Simple periodogramm with no error estimates.

static NVector AbstractDataModel.SimplexSolver(DataModel exp, NVector start, NVector length)
We use a Simplex in standard form to solve for a minimum model.

private static int SmoothParabola.slide(NVector[] data, int index, int at, double sign)
Slides up/down from a given index, until an extremum is reached and returns the index in the array.

static int SmoothParabola.slideDown(NVector[] data, int index, int around)
Slides from the given index down and returns the minimum index there.

static int SmoothParabola.slideUp(NVector[] data, int index, int around)
Slides from the given index up and returns the maximum index there.

static Vector3D SmoothParabola.smoothExtremum(NVector[] data, int steps, int xindex, int yindex, int extremum)
We returned a smoothend parabel value by the following way: Around the extremal index (see SmoothParabola.maximum(vec_math.NVector[], int) etc), we take the values +1/-1, if permitted by the array size or two pixel to the left/right of index. We fit a parabel through these points and record x and y of the extremum. For step trials, we add points from the left/right of the current active points, whoever is closer to the extremal value (array size permitting). For each set of trial points, we fit a regression parabola and record x and y of the extremum, as well as fwhm^2. We return the median x, y and fwhm^2 of all parabolas.

NVector QuadMatrix.solve(NVector rhs)
Solves the system of linear equations represented by this quadmatrix for the system

protected static double Fourier.Series.solve(NVector fanbn, double t)
We evaluate a fourier series for a given set of amplitudes and a principal frequency for the given time t.

static NVector QuadMatrix.solve(QuadMatrix q, NVector rhs)
Solves the system of linear equations represented by this quadmatrix for the system

static



<T extends NVector> 


T[]

NVector.sort(T[] unsorted,
     int index)

Data must be sorted according to given indices values.

private static Vector2D MinimumStringLength.strlen(NVector[] unscaled, double period, double ymin, double ymax)
Calculates a single string length for a given period.

static NVector NVector.subtract(NVector s1, NVector s2, NVector dest)
Returns the subtraction of two vectors with equal dimension.

static String LineVector.toString(NVector n)
The string representation of a line vector.

NVector[] StatisticAnalyser.visualize(NVector[] in, NVector[] v)
Data is already reduced to minimum.

NVector[] MultipleFrequencyFit.visualize(NVector[] in, NVector[] allfits)
Visualized data is the original data minus the highest-order Fourier fit.

NVector[] LeastFourier.visualize(NVector[] in, NVector[] allfits)
Visualized data is the original data minus the highest-order Fourier fit.

NVector[] Fourier.visualize(NVector[] in, NVector[] ft)
Calls the periodogram.

NVector[] Analyser.visualize(NVector[] in, NVector[] processed)
Further transforms the processed vector into some visualizable vector.

NVector[] AbstractAnalyser.visualize(NVector[] in, NVector[] out)
Default implementation of visualization returns just the output data.

Method parameters in vec_math with type arguments of type NVector
`private NVector`	`MultipleFrequencyFit.improve(NVector[] in, List<NVector> freqs, int[] fixorder)` Improvement of multidimensional fourier fit means we take a vector of frequencies and amplitudes, construct single-order fourier series out of them and let all frequencies and amplitudes varry, except those stated in the fixed orders array.

Constructors in vec_math with parameters of type NVector
`AbstractDataModel(NVector[] times, double[] data, double[] err)` We construct an abstract data model by providing the dependant variables at the measurement points.
`AbstractGradientModel(NVector[] times, double[] y, double[] err)` Chains.
`Bootstrap.ExchangedData(NVector[] xsim, NVector ysim, NVector errsim)` Constructs a new container for a simulated data set.
`Bootstrap.ExchangedData(NVector[] xsim, NVector ysim, NVector errsim)` Constructs a new container for a simulated data set.
`Bootstrap.ExchangedData(NVector[] xsim, NVector ysim, NVector errsim, NVector[] xd, NVector yd, NVector errd)` Constructs a new container for a simulated data set.
`Bootstrap.ExchangedData(NVector[] xsim, NVector ysim, NVector errsim, NVector[] xd, NVector yd, NVector errd)` Constructs a new container for a simulated data set.
`Bootstrap.ExchangedData(NVector[] xsim, NVector ysim, NVector errsim, NVector[] xd, NVector yd, NVector errd)` Constructs a new container for a simulated data set.
`Bootstrap(Function[] fitting, NVector x, NVector y, NVector sigma)` Constructs a new bootstrap object from the supplied basic functions and the measurement with their errors.
`Bootstrap(Multidimensional[] fitting, NVector[] x, NVector y, NVector sigma)` Constructs a new bootstrap object from the supplied basic functions and the measurement with their errors.
`Bootstrap(Multidimensional[] fitting, NVector[] x, NVector y, NVector sigma)` Constructs a new bootstrap object from the supplied basic functions and the measurement with their errors.
`Bootstrap(NVector y, NVector sigma)` Common constructor.
`ClassicStatistic(NVector[] val, int vi, int si)` Constructs a ready-to-use statistic object out of a NVector.
`ExpressionFit.AmoebaModel(String model, NVector[] mag, int y)` Constructs a new Amoeba Model.
`GeneralLinearRegression(Function[] fitting, NVector x, NVector y, NVector sigma)` Constructs a new general linear regression.
`GeneralLinearRegression(Multidimensional[] fitting, NVector[] x, NVector y, NVector sigma)` Constructs a new general linear regression.
`GeneralLinearRegression(Multidimensional[] fitting, NVector[] x, NVector y, NVector sigma)` Constructs a new general linear regression.
`HarmonicFit.HarmonicModel(NVector[] times, double[] y, double[] err, double ext2)`
`LevenbergMarquardt.LMSineModel(NVector[] times, double[] y, double[] err)`
`LevenbergMarquardt.SinusModel(NVector[] times, double[] y, double[] err)`
`MultipleFrequencyFit.FourierComponents(int count, NVector[] times, double[] y, double[] err)`
`PhaseRegression.PhaseModel(NVector t, NVector y)`
`PhaseRegression.PhaseModel(NVector t, NVector y, double p)`
`Statistic(NVector[] val, int vi)` Constructs a ready-to-use statistic object out of a NVector array.
`StepFunction(NVector[] grid)` Constructs a step function with a grid of sampling.

Constructor parameters in vec_math with type arguments of type NVector
`Statistic(List<? extends NVector> val, int vi)` Constructs a ready-to-use statistic object out of a NVector.

Uses of NVector in view

Fields in view declared as NVector
`private NVector`	`DataCard.point` The data point in user space.

Methods in view that return NVector
`NVector`	`DataCard.getPoint()` Returns the point location.

Constructors in view with parameters of type NVector
`DataCard(NVector xy, Object id)` Construct a new card.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Classvec_math.NVector

Uses of Class
vec_math.NVector