Package decide

Class LIC

java.lang.Object
decide.LIC
public class LIC extends Object
Class for the LIC functions.

  • Constructor Summary

    Constructors
    Modifier
    Constructor
    Description
    protected
    LIC()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static boolean[]
    calculateCmv(Parameters parameters, ArrayList<Point2D> points, int numPoints)
    Method to calculate the CMV.
    protected static boolean
    lic1(ArrayList<Point2D> points, double length1)
    Method for LIC 1 There exists at least one set of two consecutive data points that are a distance greater than the length, LENGTH1, apart.
    protected static boolean
    lic10(ArrayList<Point2D> points, int numpoints, int cpts, int dpts, double epsilon)
    There exists at least one set of three data points separated by exactly cpts and dpts consecutive intervening points, respectively, that form an angle such that: angle < (PI − EPSILON) or angle > (PI + EPSILON) The second point of the set of three points is always the vertex of the angle.
    protected static boolean
    lic11(ArrayList<Point2D> points, int numpoints, double area1, int epts, int fpts)
    There exists at least one set of three data points separated by exactly E PTS and F PTS consecutive intervening points, respectively, that are the vertices of a triangle with area greater than AREA1.
    protected static boolean
    lic12(ArrayList<Point2D> points, int gpts)
    Method for LIC 12 There exists at least one set of two data points, (X[i],Y[i]) and (X[j],Y[j]), separated by exactly G PTS consecutive intervening points, such that X[j] - X[i] < 0.
    protected static boolean
    lic13(ArrayList<Point2D> points, int kpts, double length1, double length2, int numpoints)
    There exists at least one set of two data points, separated by exactly K PTS consecutive intervening points, which are a distance greater than the length, LENGTH1, apart.
    protected static boolean
    lic14(ArrayList<Point2D> points, int numpoints, double radius1, double radius2, int apts, int bpts)
    There exists at least one set of three data points, separated by exactly A PTS and B PTS consecutive intervening points, respectively, that cannot be contained within or on a circle of radius RADIUS1.
    protected static boolean
    lic15(ArrayList<Point2D> points, int numpoints, double area1, double area2, int epts, int fpts)
    There exists at least one set of three data points, separated by exactly E_PTS and F_PTS consecutive intervening points, respectively, that are the vertices of a triangle with area greater than AREA1.
    protected static boolean
    lic2(ArrayList<Point2D> points, double radius1)
    There exists at least one set of three consecutive data points that cannot all be contained within or on a circle of radius RADIUS1.
    protected static boolean
    lic3(ArrayList<Point2D> points, double epsilon)
    There exists at least one set of three consecutive data points which form an angle such that angle < (PI−EPSILON) or angle > (PI+EPSILON) The second of the three consecutive points is always the vertex of the angle.
    protected static boolean
    lic4(ArrayList<Point2D> points, double area1)
    A method for LIC 4.
    protected static boolean
    lic5(ArrayList<Point2D> points, int qpts, int quads, int numpoints)
    LIC 5 There exists at least one set of Q PTS consecutive data points that lie in more than QUADS quadrants.
    protected static boolean
    lic6(ArrayList<Point2D> points, int numpoints)
    There exists at least one set of two consecutive data points, (X[i], Y[i]) and (X[j], Y[j]), such that X[j] - X[i] < 0.
    protected static boolean
    lic7(ArrayList<Point2D> points, int numpoints, int npts, double dist)
    There exists at least one set of N_PTS consecutive data points such that at least one of the points lies a distance greater than DIST from the line joining the first and last of these N_PTS points.
    protected static boolean
    lic8(ArrayList<Point2D> points, int numpoints, int kpts, double length1)
    There exists at least one set of two data points separated by exactly K_PTS consecutive intervening points that are a distance greater than the length, LENGTH1, apart.
    protected static boolean
    lic9(ArrayList<Point2D> points, int numpoints, double radius1, int apts, int bpts)
    There exists at least one set of three data points separated by exactly A PTS and B PTS consecutive intervening points, respectively, that cannot be contained within or on a circle of radius RADIUS1.

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • LIC

      protected LIC()

  • Method Details

    • lic1

      protected static boolean lic1(ArrayList<Point2D> points, double length1)
      Method for LIC 1 There exists at least one set of two consecutive data points that are a distance greater than the length, LENGTH1, apart. (0 ≤ LENGTH1)
      Parameters:
      points - Array containing the coordinates of data points
      length1 - Distance that two points need to be from each other
      Returns:
      True if LIC 1 is met

    • lic2

      protected static boolean lic2(ArrayList<Point2D> points, double radius1)
      There exists at least one set of three consecutive data points that cannot all be contained within or on a circle of radius RADIUS1. (0 ≤ RADIUS1)
      Parameters:
      points - Array containing the coordinates of data points.
      radius1 - Radius of circle that should not cover the points.
      Returns:
      True if LIC2 is met

    • lic3

      protected static boolean lic3(ArrayList<Point2D> points, double epsilon)
      There exists at least one set of three consecutive data points which form an angle such that angle < (PI−EPSILON) or angle > (PI+EPSILON) The second of the three consecutive points is always the vertex of the angle. If either the first point or the last point (or both) coincides with the vertex, the angle is undefined and the LIC is not satisfied by those three points. (0 ≤ EPSILON ≤ PI)
      Parameters:
      points - Array containing coordinates of data points
      epsilon - Deviation from pi
      Returns:
      true if all the conditions are met

    • lic4

      protected static boolean lic4(ArrayList<Point2D> points, double area1)
      A method for LIC 4. There exists at least one set of three consecutive data points that are the vertices of a triangle with area greater than AREA1
      Parameters:
      points - Array containing the coordinates of data points
      area1 - Area in LICs
      Returns:
      true iff LIC 4 is met

    • lic5

      protected static boolean lic5(ArrayList<Point2D> points, int qpts, int quads, int numpoints)
      LIC 5 There exists at least one set of Q PTS consecutive data points that lie in more than QUADS quadrants. Where there is ambiguity as to which quadrant contains a given point, priority of decision will be by quadrant number, i.e., I, II, III, IV. For example, the data point (0,0) is in quadrant I, the point (-l,0) is in quadrant II, the point (0,-l) is in quadrant III, the point (0,1) is in quadrant I and the point (1,0) is in quadrant I. (2 ≤ Q PTS ≤ NUMPOINTS), (1 ≤ QUADS ≤ 3)
      Parameters:
      points - Array containing the coordinates of data points
      qpts - Number of consecutive points
      quads - Least number of quadrants that should be inhabited -1
      numpoints - Number of points in points array
      Returns:
      True if LIC 5 is met

    • lic6

      protected static boolean lic6(ArrayList<Point2D> points, int numpoints)
      There exists at least one set of two consecutive data points, (X[i], Y[i]) and (X[j], Y[j]), such that X[j] - X[i] < 0. (where i = j - 1)
      Parameters:
      points - Array containing the coordinates of data points
      numpoints - The number of planar data points
      Returns:
      true iff LIC 6 is met

    • lic7

      protected static boolean lic7(ArrayList<Point2D> points, int numpoints, int npts, double dist)
      There exists at least one set of N_PTS consecutive data points such that at least one of the points lies a distance greater than DIST from the line joining the first and last of these N_PTS points. If the first and last points of these N_PTS are identical, then the calculated distance to compare with DIST will be the distance from the coincident point to all other points of the N_PTS consecutive points. The condition is not met when NUMPOINTS < 3. (3 ≤ N_PTS ≤ NUMPOINTS), (0 ≤ DIST)
      Parameters:
      points - Array containing the coordinates of data points
      numpoints - The number of planar data points
      npts - Number of consecutive points
      dist - Distance
      Returns:
      true iff LIC 7 is satisfied

    • lic8

      protected static boolean lic8(ArrayList<Point2D> points, int numpoints, int kpts, double length1)
      There exists at least one set of two data points separated by exactly K_PTS consecutive intervening points that are a distance greater than the length, LENGTH1, apart. The condition is not met when NUMPOINTS < 3.
      Parameters:
      points - Array containing the coordinates of data points
      numpoints - The number of planar data points
      kpts - Number of intervening points
      length1 - Distance that two points need to be from each other
      Returns:
      true iff LIC 8 is met

    • lic10

      protected static boolean lic10(ArrayList<Point2D> points, int numpoints, int cpts, int dpts, double epsilon)
      There exists at least one set of three data points separated by exactly cpts and dpts consecutive intervening points, respectively, that form an angle such that: angle < (PI − EPSILON) or angle > (PI + EPSILON) The second point of the set of three points is always the vertex of the angle. If either the first point or the last point (or both) coincide with the vertex, the angle is undefined and the LIC is not satisfied by those three points. When numpoints < 5, the condition is not met. 1 ≤ C PTS, 1 ≤ D PTS C PTS+D PTS ≤ numpoints − 3
      Parameters:
      cpts - Number of intervening points
      dpts - Number of intervening points
      epsilon - Deviation from pi
      numpoints - Number of planar data points
      points - Array containing the coordinates of data points
      Returns:
      true if lic 10 is met

    • lic9

      protected static boolean lic9(ArrayList<Point2D> points, int numpoints, double radius1, int apts, int bpts)
      There exists at least one set of three data points separated by exactly A PTS and B PTS consecutive intervening points, respectively, that cannot be contained within or on a circle of radius RADIUS1. The condition is not met when NUMPOINTS is less than 5. A PTS and B PTS must be more or equal to 1. A PTS + B PTS ≤ (NUMPOINTS−3)
      Parameters:
      points - Array with coordinates of datapoints
      numpoints - Number of points in array
      radius1 - First radius of lic
      apts - Number of points separating data points
      bpts - Number of points separating data points
      Returns:
      true if the conditions are met

    • lic11

      protected static boolean lic11(ArrayList<Point2D> points, int numpoints, double area1, int epts, int fpts)
      There exists at least one set of three data points separated by exactly E PTS and F PTS consecutive intervening points, respectively, that are the vertices of a triangle with area greater than AREA1. The condition is not met when NUMPOINTS < 5.
      Parameters:
      points - Array containing the coordinates of data points
      numpoints - The number of planar data points
      area1 - Area in LICs
      epts - Number of points between the 1st and the 2nd data point
      fpts - Number of points between the 2nd and the 3rd data point
      Returns:
      true iff LIC 10 is met

    • lic12

      protected static boolean lic12(ArrayList<Point2D> points, int gpts)
      Method for LIC 12 There exists at least one set of two data points, (X[i],Y[i]) and (X[j],Y[j]), separated by exactly G PTS consecutive intervening points, such that X[j] - X[i] < 0. (where i < j ) The condition is not met when NUMPOINTS < 3. 1 ≤ G PTS ≤ NUMPOINTS−2
      Parameters:
      points - ArrayList of points
      gpts - Number of points between pairs of points to check
      Returns:
      true if condition is met

    • lic13

      protected static boolean lic13(ArrayList<Point2D> points, int kpts, double length1, double length2, int numpoints)
      There exists at least one set of two data points, separated by exactly K PTS consecutive intervening points, which are a distance greater than the length, LENGTH1, apart. In addition, there exists at least one set of two data points (which can be the same or different from the two data points just mentioned), separated by exactly K PTS consecutive intervening points, that are a distance less than the length, LENGTH2, apart. Both parts must be true for the LIC to be true. The condition is not met when NUMPOINTS < 3. 0 ≤ LENGTH2
      Parameters:
      points - Array containing coordinates of data points
      kpts - Number separating the 2 data points
      length1 - Minimum distance
      length2 - Maximum distance
      numpoints - Number of planar data points
      Returns:
      true if the conditions of lic13 is met

    • lic14

      protected static boolean lic14(ArrayList<Point2D> points, int numpoints, double radius1, double radius2, int apts, int bpts)
      There exists at least one set of three data points, separated by exactly A PTS and B PTS consecutive intervening points, respectively, that cannot be contained within or on a circle of radius RADIUS1. In addition, there exists at least one set of three data points (which can be the same or different from the three data points just mentioned) separated by exactly A PTS and B PTS consecutive intervening points, respectively, that can be contained in or on a circle of radius RADIUS2. Both parts must be true for the LIC to be true. The condition is not met when NUMPOINTS is < 5. (0 ≤ RADIUS2)
      Parameters:
      points - Array containing the coordinates of data points
      numpoints - The number of planar data points
      radius1 - 1st Radius in LICs
      radius2 - 2nd Radius in LICs
      apts - Number of points between the 1st and the 2nd data points
      bpts - Number of points between the 2nd and the 3rd data points
      Returns:
      true iff LIC 14 is met

    • lic15

      protected static boolean lic15(ArrayList<Point2D> points, int numpoints, double area1, double area2, int epts, int fpts)
      There exists at least one set of three data points, separated by exactly E_PTS and F_PTS consecutive intervening points, respectively, that are the vertices of a triangle with area greater than AREA1. In addition, there exist three data points (which can be the same or different from the three data points just mentioned) separated by exactly E PTS and F PTS consecutive intervening points, respectively, that are the vertices of a triangle with area less than AREA2. Both parts must be true for the LIC to be true. The condition is not met when NUMPOINTS < 5.
      Parameters:
      points - Array containing the coordinates of data points
      numpoints - The number of planar data points
      area1 - 1st Area in LICs
      area2 - 2nd Area in LICs
      epts - Number of points between the 1st and the 2nd data point
      fpts - Number of points between the 2nd and the 3rd data point
      Returns:
      true iff LIC 14 is met

    • calculateCmv

      public static boolean[] calculateCmv(Parameters parameters, ArrayList<Point2D> points, int numPoints)
      Method to calculate the CMV.
      Parameters:
      parameters - Parameters to calculate CMV
      points - Planner points
      numPoints - Length of points
      Returns:
      the CMV