for (int i = 0; i < ts.length - windowSize; i++) 

for (int i = 0; i <= ts.length - windowSize; i++) 

x <- array(1:7, dim=c(7))
l <- length(x)
PAA_number = 4
PAA <- array(0, PAA_number)
for (i in 1:PAA_number) {
  PAA[i] <- mean(x[round((i - 1) * l/PAA_number + 1):round(i * l/PAA_number)])
  print(paste("segment",i,"[",      # a debug output
          round((i - 1) * l/PAA_number + 1),
          ":",round(i * l/PAA_number),"] ->",
          PAA[i]))
}

[1] "segment 1 [ 1 : 2 ] -> 1.5"
[1] "segment 2 [ 3 : 4 ] -> 3.5"
[1] "segment 3 [ 4 : 5 ] -> 4.5"
[1] "segment 4 [ 6 : 7 ] -> 6.5"

package net.seninp.jmotif.sax.alphabet;

import net.seninp.jmotif.sax.SAXException;

public class GeneralAlphabet extends Alphabet
{
    @Override
    public Integer getMaxSize()
    {
        return Integer.MAX_VALUE;
    }

    @Override
    public double[] getCuts(Integer size) throws SAXException
    {
        return computeEquiprobableRegions(size);
    }

    @Override
    public double[][] getDistanceMatrix(Integer size) throws SAXException
    {
        return computeDistanceMatrix(getCuts(size));
    }

    /**
     * The square root of two
     */
    private static final double SQRT_TWO = Math.sqrt(2);

    /**
     * Create an array that describes the breakpoints for dividing a
     * Gaussian distribution into equiprobable regions.  
     *  
     * @param n The number of bisection points
     * @return The array
     */
    private static double[] computeEquiprobableRegions(int n)
    {
        double b[] = new double[n - 1];
        for (int s = 1; s <= n - 1; s++)
        {
            double x = ((double) s / n);
            b[s - 1] = probit(x);
        }
        return b;
    }

    /**
     * The probit function.<br> 
     * <br>
     * (See http://en.wikipedia.org/wiki/Probit)
     * 
     * @param x The argument
     * @return The result
     */
    private static double probit(double x)
    {
        return SQRT_TWO * erfInv(2 * x - 1);
    }

    /**
     * The inverse error function.<br>
     * <br> 
     * (See http://en.wikipedia.org/wiki/Error_function)
     * 
     * @param x The argument
     * @return The result
     */
    private static double erfInv(double x)
    {
        // From https://people.maths.ox.ac.uk/gilesm/files/gems_erfinv.pdf
        double w = -Math.log((1.0 - x) * (1.0 + x));
        double p = 0;
        if (w < 5.0)
        {
            w = w - 2.5;
            p = 2.81022636e-08;
            p = 3.43273939e-07 + p * w;
            p = -3.5233877e-06 + p * w;
            p = -4.39150654e-06 + p * w;
            p = 0.00021858087 + p * w;
            p = -0.00125372503 + p * w;
            p = -0.00417768164 + p * w;
            p = 0.246640727 + p * w;
            p = 1.50140941 + p * w;
        }
        else
        {
            w = Math.sqrt(w) - 3.0;
            p = -0.000200214257;
            p = 0.000100950558 + p * w;
            p = 0.00134934322 + p * w;
            p = -0.00367342844 + p * w;
            p = 0.00573950773 + p * w;
            p = -0.0076224613 + p * w;
            p = 0.00943887047 + p * w;
            p = 1.00167406 + p * w;
            p = 2.83297682 + p * w;
        }
        return p * x;
    }

    /**
     * Computes the MINDIST lookup matrix, as described in the SAX paper
     * 
     * @param b The breakpoints, as computed with 
     * {@link #computeEquiprobableRegions(int)}
     * @return The distance matrix
     */
    private static double[][] computeDistanceMatrix(double b[])
    {
        int n = b.length + 1;
        double result[][] = new double[n][n];
        for (int r = 0; r < n; r++)
        {
            for (int c = r; c < n; c++)
            {
                double value = 0;
                if (Math.abs(r - c) > 1)
                {
                    value = b[Math.max(r, c) - 1] - b[Math.min(r, c)];
                }
                result[r][c] = value;
                result[c][r] = value;
            }
        }
        return result;
    }    
}

package net.seninp.jmotif.sax.alphabet;

import java.util.LinkedHashMap;
import java.util.Map;

import net.seninp.jmotif.sax.SAXException;

public class CachingAlphabet extends Alphabet
{
    private final Alphabet delegate;
    private final Map<Integer, double[]> cuts;
    private final Map<Integer, double[][]> distanceMatrices;

    CachingAlphabet(Alphabet delegate)
    {
        this.delegate = delegate;
        this.cuts = new LinkedHashMap<Integer, double[]>();
        this.distanceMatrices = new LinkedHashMap<Integer, double[][]>();
    }

    @Override
    public Integer getMaxSize()
    {
        return delegate.getMaxSize();
    }

    @Override
    public double[] getCuts(Integer size) throws SAXException
    {
        double result[] = cuts.get(size);
        if (result == null)
        {
            result = delegate.getCuts(size);
            cuts.put(size, result);
        }
        return result;
    }

    @Override
    public double[][] getDistanceMatrix(Integer size) throws SAXException
    {
        double result[][] = distanceMatrices.get(size);
        if (result == null)
        {
            result = delegate.getDistanceMatrix(size);
            distanceMatrices.put(size, result);
        }
        return result;
    }
}

Alphabet alphabet = new CachingAlphabet(new GenericAlphabet());

package net.seninp.jmotif.sax.alphabet;

import java.util.Locale;

import net.seninp.jmotif.sax.SAXException;

public class AlphabetTest
{
    public static void main(String[] args) throws SAXException
    {
        NormalAlphabet a0 = new NormalAlphabet();
        GeneralAlphabet a1 = new GeneralAlphabet();

        int max = Math.min(a0.getMaxSize(), a1.getMaxSize());
        for (int i = 2; i < max; i++)
        {
            double[] c0 = a0.getCuts(i);
            double[] c1 = a1.getCuts(i);

            System.out.println("For " + i);
            //System.out.println("c1: "+Arrays.toString(c0));
            //System.out.println("c0: "+Arrays.toString(c1));

            double d0[][] = a0.getDistanceMatrix(i);
            double d1[][] = a1.getDistanceMatrix(i);

            //System.out.println("d0:\n" + createString(d0));
            //System.out.println("d1:\n" + createString(d1));

            System.out.println("maxAbsoluteDifference for cuts           : " + 
                maxAbsoluteDifference(c0, c1));
            System.out.println("maxAbsoluteDifference for distance matrix: " + 
                maxAbsoluteDifference(d0, d1));
        }
    }

    private static double maxAbsoluteDifference(double a0[], double a1[])
    {
        double maxAbsoluteDifference = Double.NEGATIVE_INFINITY;
        for (int i = 0; i < a0.length; i++)
        {
            double d = Math.abs(a0[i] - a1[i]);
            maxAbsoluteDifference = Math.max(maxAbsoluteDifference, d);
        }
        return maxAbsoluteDifference;
    }

    private static double maxAbsoluteDifference(double a0[][], double a1[][])
    {
        double maxAbsoluteDifference = Double.NEGATIVE_INFINITY;
        for (int i = 0; i < a0.length; i++)
        {
            maxAbsoluteDifference = Math.max(maxAbsoluteDifference, 
                maxAbsoluteDifference(a0[i], a1[i]));
        }
        return maxAbsoluteDifference;
    }

    private static String createString(double a[][])
    {
        StringBuilder sb = new StringBuilder();
        for (int r=0; r<a.length; r++)
        {
            if (r > 0)
            {
                sb.append("\n");
            }
            for (int c=0; c<a[r].length; c++)
            {
                if (c > 0)
                {
                    sb.append("  ");
                }
                sb.append(String.format(Locale.ENGLISH, "%5.5f", a[r][c]));
            }
        }
        return sb.toString();
    }
}

}
    if (series.length > 0) {
        return res / (double)series.length;
}
return Double.NaN;