for(int x = 0; x < newLabels.length; x++)
            labels.add(newLabels[x]);

    }

    public void setLabels(ArrayList newLabels)
    {
        labels.clear();
        for(int x = 0; x < newLabels.size(); x++)
            labels.add(newLabels.get(x));

    }

    public double getMeasurement(int pointIndex, int valueIndex)
    {
        return ((TimeSeriesPoint)tsArray.get(pointIndex)).get(valueIndex);
    }

    public double getMeasurement(int pointIndex, String valueLabel)
    {
        int valueIndex = labels.indexOf(valueLabel);
        if(valueIndex < 0)
            throw new InternalError("ERROR:  the label '" + valueLabel + "' was " + "not one of:  " + labels);
        else
            return ((TimeSeriesPoint)tsArray.get(pointIndex)).get(valueIndex - 1);
    }

    public double getMeasurement(double time, int valueIndex)
    {
        return 0.0D;
    }

    public double getMeasurement(double time, String valueLabel)
    {
        int valueIndex = labels.indexOf(valueLabel);
        if(valueIndex < 0)
            throw new InternalError("ERROR:  the label '" + valueLabel + "' was " + "not one of:  " + labels);
        else
            return getMeasurement(time, valueIndex);
    }

    public double[] getMeasurementVector(int pointIndex)
    {
        return ((TimeSeriesPoint)tsArray.get(pointIndex)).toArray();
    }

    public double[] getMeasurementVector(double time)
    {
        return null;
    }

    public void setMeasurement(int pointIndex, int valueIndex, double newValue)
    {
        ((TimeSeriesPoint)tsArray.get(pointIndex)).set(valueIndex, newValue);
    }

    public void addFirst(double time, TimeSeriesPoint values)
    {
        if(labels.size() != values.size() + 1)
            throw new InternalError("ERROR:  The TimeSeriesPoint: " + values + " contains the wrong number of values. " + "expected:  " + labels.size() + ", " + "found: " + values.size());
        if(time >= ((Double)timeReadings.get(0)).doubleValue())
        {
            throw new InternalError("ERROR:  The point being inserted into the beginning of the time series does not have the correct time sequence. ");
        } else
        {
            timeReadings.add(0, new Double(time));
            tsArray.add(0, values);
            return;
        }
    }

    public void addLast(double time, TimeSeriesPoint values)
    {
        if(labels.size() != values.size() + 1)
            throw new InternalError("ERROR:  The TimeSeriesPoint: " + values + " contains the wrong number of values. " + "expected:  " + labels.size() + ", " + "found: " + values.size());
        if(size() > 0 && time <= ((Double)timeReadings.get(timeReadings.size() - 1)).doubleValue())
        {
            throw new InternalError("ERROR:  The point being inserted at the end of the time series does not have the correct time sequence. ");
        } else
        {
            timeReadings.add(new Double(time));
            tsArray.add(values);
            return;
        }
    }

    public void removeFirst()
    {
        if(size() == 0)
        {
            System.err.println("WARNING:  TimeSeriesPoint:removeFirst() called on an empty time series!");
        } else
        {
            timeReadings.remove(0);
            tsArray.remove(0);
        }
    }

    public void removeLast()
    {
        if(size() == 0)
        {
            System.err.println("WARNING:  TimeSeriesPoint:removeLast() called on an empty time series!");
        } else
        {
            timeReadings.remove(timeReadings.size() - 1);
            tsArray.remove(timeReadings.size() - 1);
        }
    }

    public void normalize()
    {
        double mean[] = new double[numOfDimensions()];
        for(int col = 0; col < numOfDimensions(); col++)
        {
            double currentSum = 0.0D;
            for(int row = 0; row < size(); row++)
                currentSum += getMeasurement(row, col);

            mean[col] = currentSum / (double)size();
        }

        double stdDev[] = new double[numOfDimensions()];
        for(int col = 0; col < numOfDimensions(); col++)
        {
            double variance = 0.0D;
            for(int row = 0; row < size(); row++)
                variance += Math.abs(getMeasurement(row, col) - mean[col]);

            stdDev[col] = variance / (double)size();
        }

        for(int row = 0; row < size(); row++)
        {
            for(int col = 0; col < numOfDimensions(); col++)
                if(stdDev[col] == 0.0D)
                    setMeasurement(row, col, 0.0D);
                else
                    setMeasurement(row, col, (getMeasurement(row, col) - mean[col]) / stdDev[col]);

        }

    }

    public String toString()
    {
        StringBuffer outStr = new StringBuffer();
        for(int r = 0; r < timeReadings.size(); r++)
        {
            TimeSeriesPoint values = (TimeSeriesPoint)tsArray.get(r);
            for(int c = 0; c < values.size(); c++)
                outStr.append(values.get(c));

            if(r < timeReadings.size() - 1)
                outStr.append("\n");
        }

        return outStr.toString();
    }

    private static char determineDelimiter(String filePath)
    {
        char DEFAULT_DELIMITER = ',';
        String line;
        int x;
        BufferedReader in = new BufferedReader(new FileReader(filePath));
        line = in.readLine().trim();
        if(!Character.isDigit(line.charAt(0)))
            line = in.readLine();
        in.close();
        x = 0;
_L1:
        if(x >= line.length())
            break MISSING_BLOCK_LABEL_120;
        if(!Character.isDigit(line.charAt(x)) && line.charAt(x) != '.' && line.charAt(x) != '-' && Character.toUpperCase(line.charAt(x)) != 'E')
            return line.charAt(x);
        x++;
          goto _L1
        return ',';
        IOException e;
        e;
        return ',';
    }

    private static double extractFirstNumber(String str)
    {
        StringBuffer numStr = new StringBuffer();
        for(int x = 0; x < str.length(); x++)
            if(Character.isDigit(str.charAt(x)) || str.charAt(x) == '.' || str.charAt(x) == '-' || Character.toUpperCase(str.charAt(x)) == 'E')
                numStr.append(str.charAt(x));
            else
                Double.parseDouble(numStr.toString());

        return -1D;
    }

    private static boolean determineIsFirstColTime(String filePath)
    {
        boolean DEFAULT_VALUE = false;
        Vector possibleTimeValues;
        BufferedReader in = new BufferedReader(new FileReader(filePath));
        double EQUALITY_FLEXIBILITY_PCT = 0.001D;
        int NUM_OF_VALUES_TO_CMP = 100;
        possibleTimeValues = new Vector(100);
        for(String line = in.readLine(); possibleTimeValues.size() < 100 && (line = in.readLine()) != null; possibleTimeValues.add(new Double(extractFirstNumber(line))));
        if(possibleTimeValues.size() <= 1)
            return false;
        if(possibleTimeValues.size() > 1 && possibleTimeValues.get(1).equals(possibleTimeValues.get(0)))
            return false;
        double expectedDiff;
        double flexibility;
        int x;
        expectedDiff = ((Double)possibleTimeValues.get(1)).doubleValue() - ((Double)possibleTimeValues.get(0)).doubleValue();
        flexibility = expectedDiff * 0.001D;
        x = 1;
_L1:
        if(x >= possibleTimeValues.size())
            break MISSING_BLOCK_LABEL_224;
        if(Math.abs(((Double)possibleTimeValues.get(x)).doubleValue() - ((Double)possibleTimeValues.get(x - 1)).doubleValue() - expectedDiff) > Math.abs(flexibility))
            return false;
        x++;
          goto _L1
        return true;
        IOException e;
        e;
        return false;
    }

    protected void setMaxCapacity(int capacity)
    {
        timeReadings.ensureCapacity(capacity);
        tsArray.ensureCapacity(capacity);
    }

}