Main

## Class UtilityMethods

- java.lang.Object
- - Main.UtilityMethods

-     public class UtilityMethods
      extends java.lang.Object

  This class contains a number of useful public static method.
  Author:
    Hamoon

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static java.lang.String` | `newLineString`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `UtilityMethods()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <T> void` | `addAllWithoutRepetition(java.util.List<T> L, java.util.List<T> R)` add elements of R that does not exits in L to L.
    `static <T> boolean` | `areEqual(java.util.List<T> L, java.util.List<T> R)` Checks if the set of L and R are equal.
    `static java.lang.String` | `get_address_for_automata_library()`
    `static java.lang.String` | `get_address_for_command_files()`
    `static java.lang.String` | `get_address_for_custom_bases()`
    `static java.lang.String` | `get_address_for_result()`
    `static java.lang.String` | `get_address_for_test_library()`
    `static java.lang.String` | `get_address_for_words_library()`
    `static boolean` | `isNumber(java.lang.String s)` checks if a string is \\d+
    `static char` | `max(char a, char b)`
    `static char` | `min(char a, char b)`
    `static java.lang.String` | `newLine()`
    `static int` | `parseInt(java.lang.String s)`
    `static <T> java.util.List<T>` | `permute(java.util.List<T> L, int[] permutation)` permutes L with regard to permutation.
    `static <T> void` | `removeDuplicates(java.util.List<T> L)` For example when L = [1,3,2,1,3] the result is [1,3,2]
    `static <T> void` | `removeIndices(java.util.List<T> L, java.util.List<java.lang.Integer> indices)` For example when indices = [1,3] and L = [X,Y,Z,W] then the result is [X,Z]
    `static void` | `setPaths()`
    `static <T> java.lang.String` | `toTuple(java.util.List<T> l)` For example when L = [1,2,3] then the result is the string "(1,2,3)"

    - ### Methods inherited from class java.lang.Object

      `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### newLineString

          public static java.lang.String newLineString

  - ### Constructor Detail

    - #### UtilityMethods

          public UtilityMethods()

  - ### Method Detail

    - #### setPaths

          public static void setPaths()

    - #### get_address_for_command_files

          public static java.lang.String get_address_for_command_files()

    - #### get_address_for_automata_library

          public static java.lang.String get_address_for_automata_library()

    - #### get_address_for_result

          public static java.lang.String get_address_for_result()

    - #### get_address_for_custom_bases

          public static java.lang.String get_address_for_custom_bases()

    - #### get_address_for_words_library

          public static java.lang.String get_address_for_words_library()

    - #### get_address_for_test_library

          public static java.lang.String get_address_for_test_library()

    - #### min

          public static char min(char a,
                 char b)

    - #### max

          public static char max(char a,
                 char b)

    - #### newLine

          public static java.lang.String newLine()

    - #### isNumber

          public static boolean isNumber(java.lang.String s)

      checks if a string is \\d+
      Parameters:
        `s` -
      Returns:

    - #### permute

          public static <T> java.util.List<T> permute(java.util.List<T> L,
                                      int[] permutation)

      permutes L with regard to permutation. For example if permutation = [1,2,0] then the return value is [L[1],L[2],L[0]]
      Parameters:
        `L` -
        `permutation` -
      Returns:

    - #### toTuple

          public static <T> java.lang.String toTuple(java.util.List<T> l)

      For example when L = [1,2,3] then the result is the string "(1,2,3)"
      Parameters:
        `l` -
      Returns:

    - #### removeDuplicates

          public static <T> void removeDuplicates(java.util.List<T> L)

      For example when L = [1,3,2,1,3] the result is [1,3,2]
      Parameters:
        `L` -

    - #### areEqual

          public static <T> boolean areEqual(java.util.List<T> L,
                             java.util.List<T> R)

      Checks if the set of L and R are equal. L and R does not have duplicates.
      Parameters:
        `L` -
        `R` -
      Returns:

    - #### addAllWithoutRepetition

          public static <T> void addAllWithoutRepetition(java.util.List<T> L,
                                         java.util.List<T> R)

      add elements of R that does not exits in L to L.
      Parameters:
        `L` -
        `R` -

    - #### removeIndices

          public static <T> void removeIndices(java.util.List<T> L,
                               java.util.List<java.lang.Integer> indices)

      For example when indices = [1,3] and L = [X,Y,Z,W] then the result is [X,Z]
      Parameters:
        `L` -
        `indices` -

    - #### parseInt

          public static int parseInt(java.lang.String s)

      Parameters:
        `s` -
      Returns: