bioroebe 0.10.80 → 0.12.24

data/lib/bioroebe/java/README.md

@@ -4,3 +4,8 @@ bioroebe to ever be fully written in Java.
 To compile it anew, do:
 
   run bioroebe/AllInOne.java 
+
+Since as of September 2022 it is easier to run:
+
+  bioroebe --create-jar
+

data/lib/bioroebe/java/bioroebe/AllInOne.java

@@ -1,4 +1,5 @@
 package bioroebe;
+
 import bioroebe.*;
 
 /*

data/lib/bioroebe/java/bioroebe/Base.java

@@ -1,11 +1,14 @@
 package bioroebe;
+
 import bioroebe.*;
 
 /*
  * The Base class defines some constants, in particular in regards
  * to colours and console-output.
  */
-public abstract class Base {
+
+/* public abstract class Base { */
+public class Base {
 
   static boolean are_we_on_windows = System.getProperty("os.name").toLowerCase().
                                      startsWith("windows");
@@ -29,8 +32,10 @@ public abstract class Base {
   }
 
   /*
-   * Determine whether the underlying OS is Windows
-   * or whether it is not.
+   * on_windows()
+   *
+   * This method determines whether the underlying OS is
+   * Windows or whether it is not.
    */
   public static boolean on_windows() {
     return are_we_on_windows;
@@ -51,17 +56,21 @@ public abstract class Base {
   public static final String ANSI_WHITE  = "\u001B[37m"; // ANSI_WHITE
 
   /*
+   * newline()
+   *
    * Use a newline.
    */
   public static void newline() {
     System.out.println();
   }
+
   /*
    * The colour red.
    */
   public static String red(String i) {
     return ANSI_RED+i+ANSI_WHITE;
   }
+
   /*
    * The colour green.                                              (green tag)
    */
@@ -75,7 +84,9 @@ public abstract class Base {
     return ANSI_YELLOW+i+ANSI_WHITE;
   }
   /*
-   * The colour blue.
+   * === blue()
+   *
+   * The colour blue., via the constant ANSI_BLUE.
    */
   public static String blue(String i) {
     return ANSI_BLUE+i+ANSI_WHITE;
@@ -99,4 +110,27 @@ public abstract class Base {
     e(blue(i));
   }
 
-}
+  /*
+   * === en()
+   */
+  public static void en(String i) {
+    System.out.println(i);
+  }
+
+  /*
+   * === en()
+   */
+  public static void en(Boolean i) {
+    System.out.println(Boolean.toString(i));
+  }
+
+  /*
+   * The main method here is only used for testing purposes.
+   */
+  public static void main(String[] args) {
+    Base x = new Base();
+    /* x.eblue("Blue output works."); */
+    x.eyellow("Yellow output works.");
+  }
+  
+}

data/lib/bioroebe/java/bioroebe/IsPalindrome.java

@@ -1,18 +1,36 @@
 package bioroebe;
 
-public class IsPalindrome {
+import bioroebe.*;
+
+public class IsPalindrome extends Base {
 
   /*
-   * IsPalindrome.isPalindrome()
+   * === Bioroebe.is_palindrome()
+   *
+   * Toplevel-method to find out whether a String is a palindrome or not.
+   *
+   * Usage example:
+   *
+   *   IsPalindrome.isPalindrome("OTTO")
    *
    */
-  public static boolean isPalindrome(String i) {
-    String reversed = new StringBuffer(i).reverse().toString();
+  public static boolean is_palindrome(String i) {
+    String reversed = new StringBuffer(i).
+                          reverse().
+                          toString();
     return reversed.equals(i); /* Do the comparison here. */
   }
 
   public static void main(String[] args) {
-    System.out.println(isPalindrome("OTTO")); /* Will return true. */
+    String test1 = "";
+    if (args.length > 0) {
+      test1 = args[0];
+    }
+    else {
+      test1 = "OTTO";
+    }
+    en("Testing the String `"+test1+"` next:");
+    en(is_palindrome(test1)); /* Will return true. */
   }
 
 }

data/lib/bioroebe/java/bioroebe/Sequence.java

@@ -1,6 +1,7 @@
 package bioroebe;
 
-import java.io.*; 
+import java.io.*;
+import bioroebe.Base;
 
 /*
  * === Sequence
@@ -10,14 +11,38 @@ import java.io.*;
  */
 public class Sequence extends Base {
 
+  private static final boolean SHALL_WE_UPCASE = true;
   private static String sequence = "";
- 
+
   public static void main(String[] args) {
     sequence = String.join("", args);
   }
 
   /*
-   * return_sequence()
+   *
+   * === n_uracil?
+   *
+   * Report how many Uracil can be found in the given String. This is more
+   *  of an ad-hoc method, though.
+   */
+  int n_uracil() {
+
+    String modified_sequence = sequence.toUpperCase().replace("T","U");
+    /*.count("U");*/
+    return modified_sequence.
+           chars().
+           filter(ch -> ch == 'U').
+           count(); /* This is .count('U') */
+  }
+
+  /*
+   * === shall_we_upcase()
+   */
+  boolean shall_we_upcase() {
+    return SHALL_WE_UPCASE;
+  }
+  /*
+   * Sequence.return_sequence()
    *
    * Will return the sequence of our class Sequence instance.
    */

data/lib/bioroebe/java/bioroebe/ToCamelcase.java

@@ -9,17 +9,17 @@ package bioroebe;
 class ToCamelcase extends Base {
 
   /*
-   * === ToCamelcase.to_camelcase()
+   * === Bioroebe.to_camelcase()
    *
    * Usage example:
    *
-   *   ToCamelcase.to_camelcase("foo_bar");
-   *
+   *   ToCamelcase.to_camelcase("foo_bar"); # => "FooBar"
+   
    */
   public static String to_camelcase(String i) {
 
     StringBuilder sb = new StringBuilder();
-    
+
     for( String entry : i.toLowerCase().split("_") )
     {
       sb.append( entry.substring(0,1).toUpperCase() );
@@ -29,4 +29,16 @@ class ToCamelcase extends Base {
     return sb.toString();
   }
 
+  /*
+   * This is test-code which is why it is commented out:
+   */
+  /*
+  public static void main(String[] args) {
+    String x = "foo_bar";
+    if (args.length > 0) {
+      x = args.toString();
+    }
+    en(to_camelcase(x));
+  }
+  */
 }

data/lib/bioroebe/java/bioroebe/ToRNA.java

@@ -0,0 +1,43 @@
+/* package ToRNA; */
+package bioroebe;
+
+public class ToRNA {
+
+  static String[] commandline_arguments;
+
+  /*
+   * Main constructor (def initialize)
+   */
+  public ToRNA() {
+    run();
+  }
+  /*
+   * run()
+   */
+  void run() {
+
+    if (commandline_arguments.length > 0) {
+      for (String entry : commandline_arguments) {
+        en(entry);
+      }
+    }
+    else {
+      en("Please provide an input to this method, a DNA sequence.");
+    }
+
+  }
+
+  public static void e(String i) {
+    System.out.print(i);
+  }
+
+  public static void en(String i) {
+    System.out.println(i);
+  }
+
+  public static void main(String[] args) {
+    commandline_arguments = args;
+    ToRNA x = new ToRNA();
+  }
+
+}

data/lib/bioroebe/java/bioroebe/ToplevelMethods.java

@@ -8,6 +8,12 @@ import java.io.*;
  */
 class ToplevelMethods extends Base {
 
+  /*
+   * ToplevelMethods.bisulfite_treatment()
+   *
+   * This method will show the applied result of
+   * treating a sequence with bisulfite.
+   */
   public static String bisulfite_treatment(String i) {
     return i.replace("T","U");  
   }

data/lib/bioroebe/java/bioroebe/src/Codons.java

@@ -0,0 +1,35 @@
+package bioroebe;
+
+/*
+ * class Codons
+ *
+ * This class will include codon-related code.
+ *
+ * It is currently very unfinished, but should ideally
+ * be useable for some toplevel method calls such as:
+ *
+ *   Codons.is_valid_start_codon("UUU") # => true or false
+ *
+ */
+class Codons extends Base {
+
+  /* Designate the main start codon to use. */
+  public static String start_codon = "ATG";
+
+  /*
+   * Codons.display_start_codons()
+   *
+   * This shall simply display all valid start codons.
+   *
+   * We currently miss reporting GTG and another one;
+   * this has to be fixed eventually.
+   */
+  public static void display_start_codons() {
+    e(start_codon);
+  }
+
+  public static String return_start_codon() {
+    return start_codon;
+  }
+
+}

data/lib/bioroebe/java/bioroebe/src/Commandline.java

@@ -0,0 +1,101 @@
+/*
+ * This class will handle commandline-given input.
+ */
+package bioroebe;
+
+import bioroebe.*;
+
+public class Commandline {
+
+  /*
+   * Main constructor (def initialize)
+   */
+  String[] commandline_arguments;
+  public Commandline(String[] args) {
+    commandline_arguments = args;
+    run();
+  }
+  /*
+   * show_help()                                                     (help tag)
+   *
+   * show help instructions for this class.
+   */
+  void show_help() {
+    en("The following commandline options are available:");
+    en("");
+    en("  --partner             # complement via partner molecules");
+    en("  --random-dna-sequence # output a random DNA sequence");
+    en("");
+  }
+  /*
+   * run()
+   */
+  void run() {
+    if (commandline_arguments.length > 0) {
+      for (String entry : commandline_arguments) {
+        /* --help */
+        if (entry.matches("help|--help")) {
+          show_help();
+        }
+        /* java bioroebe/Commandline --is-palindrome */
+        else if (entry.matches("is[\s_-]*palindrome|--is_palindrome")) {
+          System.out.println(
+            IsPalindrome.isPalindrome("OTTO")
+          );
+        }
+        /* java bioroebe/Commandline --random-dna-sequence */
+        else if (entry.matches("random-dna-sequence|--random-dna-sequence")) {
+          new GenerateRandomDnaSequence(250);
+        }
+        /* java bioroebe/Commandline --base-composition */
+        else if (entry.matches("base-composition|--base-composition")) {
+          new toplevel_methods.BaseComposition(entry);
+        }
+        /* java bioroebe/Commandline --start-codons */
+        else if (entry.matches("start-codons|--start-codons")) {
+          Codons.display_start_codons();
+        }
+        /* java bioroebe/Commandline --esystem */
+        else if (entry.matches("esystem|--esystem")) {
+          Esystem.esystem("ls");
+        }
+        /* java bioroebe/Commandline --bisulfite */
+        else if (entry.matches("bisulfite|--bisulfite")) {
+          en(
+            BisulfiteTreatment.bisulfite_treatment("ATGCCCCCCCC")
+          );
+        }
+        /* java bioroebe/Commandline --remove-numbers */
+        else if (entry.matches("remove-numbers|--remove-numbers")) {
+          en(
+            RemoveNumbers.remove_numbers("123A")
+          );
+        }
+        else if (entry.matches("partner|--partner")) {
+          en(
+            PartnerNucleotide.return_partner_nucleotide("A")
+          );
+        }
+        else {
+          en("Unsure what to do with: "+entry);
+        }
+      }
+    }
+    else {
+      en("Please provide input to this class.");
+    }
+  }
+
+  public static void e(String i) {
+    System.out.print(i);
+  }
+
+  public static void en(String i) {
+    System.out.println(i);
+  }
+
+  public static void main(String[] args) {
+    Commandline x = new Commandline(args);
+  }
+
+}

data/lib/bioroebe/java/bioroebe/{Esystem.java → src/Esystem.java}

@@ -1,4 +1,5 @@
 package bioroebe;
+
 import java.io.*;
 
 /*
@@ -7,7 +8,7 @@ import java.io.*;
 public class Esystem extends Base {
 
   /*
-   * Example:
+   * Usage example:
    *
    *   Esystem.esystem("ls");
    *
@@ -42,6 +43,10 @@ public class Esystem extends Base {
     // deal with ErrorStream to get error outputs
     /*process.getErrorStream();*/
 
+    /* Next test code follows: */
+    /*
+     * Esystem.esystem("ls");
+     */
   }
 
 }

data/lib/bioroebe/java/bioroebe/{GenerateRandomDnaSequence.java → src/GenerateRandomDnaSequence.java}

@@ -9,10 +9,16 @@ class GenerateRandomDnaSequence extends Base {
 
   private String dna_sequence = null;
 
-  /* The constructer for GenerateRandomDnaSequence.
+  /*
+   * The constructor for GenerateRandomDnaSequence.
    *
    * You input a number, such as 20, and this class
    * will generate a DNA string of length 20.
+   *
+   * Usage example:
+   *
+   *   new GenerateRandomDnaSequence(250);
+   *
    */
   public GenerateRandomDnaSequence(int n_characters) {
 
@@ -26,7 +32,7 @@ class GenerateRandomDnaSequence extends Base {
       dna_sequence += alphabet.charAt(r.nextInt(alphabet.length()));
     }
 
-    e(dna_sequence);
+    e(dna_sequence); /* And output the DNA sequence here. */
   }
 
 }

data/lib/bioroebe/java/bioroebe/src/PartnerNucleotide.java

@@ -0,0 +1,56 @@
+package bioroebe;
+
+import bioroebe.*;
+
+/*
+ * PartnerNucleotide.partner_nucleotide("A");
+ *
+ * This class will simply yield the corresponding nucleotide.
+ *
+ * Usage example:
+ *
+ *   PartnerNucleotide.partner_nucleotide("A");
+ *
+ */
+class PartnerNucleotide extends Base {
+
+  /*
+   * PartnerNucleotide.partner_nucleotide()
+   */
+  public static void partner_nucleotide(String i) {
+    switch(i) {
+      case "A": e("T"); break;
+      case "T": e("A"); break;
+      case "C": e("G"); break;
+      case "G": e("C"); break;
+      default: e("Unhandled input "+i); break;
+    }
+  }
+
+  /*
+   * PartnerNucleotide.return_partner_nucleotide()
+   */
+  public static String return_partner_nucleotide(String i) {
+    switch(i) {
+      case "A": return ("T");
+      case "T": return ("A");
+      case "C": return ("G");
+      case "G": return ("C");
+      default: return ("Unhandled input "+i);
+    }
+  }
+
+  public static void main(String[] args) {
+
+    if (args.length > 0) {
+      for (String string : args) {
+        PartnerNucleotide.partner_nucleotide(string);
+      }
+    }
+    else {
+      System.out.println("Please provide input to this class, a DNA sequence.");
+    }
+
+  }
+
+}

data/lib/bioroebe/java/bioroebe/{RemoveFile.java → src/RemoveFile.java}

@@ -1,6 +1,6 @@
 package bioroebe;
 
-import java.io.*; 
+import java.io.*;
 
 /*
  * RemoveFile.remove_file("A");
@@ -18,7 +18,13 @@ class RemoveFile extends Base {
     }
     else {
       e("The file at `"+this_file+"` could NOT be deleted");
-    } 
+    }
+
+  }
+}
+
+/*
 
-  } 
-}
+  RemoveFile.remove_file("/Depot/j/test.md");
+  
+*/

data/lib/bioroebe/java/bioroebe/{RemoveNumbers.java → src/RemoveNumbers.java}

@@ -1,4 +1,5 @@
 package bioroebe;
+
 import java.util.Scanner;
 
 /*

data/lib/bioroebe/java/bioroebe/src/toplevel_methods/BaseComposition.java

@@ -0,0 +1,75 @@
+/* package BaseComposition; */
+/*package bioroebe.toplevel_methods;*/
+
+package bioroebe;
+
+public class BaseComposition {
+
+  static String[] commandline_arguments;
+
+  /*
+   * Main constructor (def initialize)
+   */
+  public BaseComposition() {
+    run();
+  }
+  /*
+   * run()
+   */
+  void run() {
+    if (commandline_arguments.length == 0) {
+      en("Please provide an input argument.");
+    }
+    else {
+      String first_argument = commandline_arguments[0];
+      en(
+        "The base composition frequencies of this sequence "+
+        "(length: "+first_argument.length()+") is as follows:"
+      );
+      en("");
+      int total_length = first_argument.length();
+      int n_A = 0;
+      int n_T = 0;
+      int n_C = 0;
+      int n_G = 0;
+
+      for (int i = 0; i < total_length; i++) {
+        char this_char = first_argument.charAt(i);
+        if (this_char == 'A') {
+          n_A += 1;
+        }
+        else if (this_char == 'T') {
+          n_T += 1;
+        }
+        else if (this_char == 'C') {
+          n_C += 1;
+        }
+        else if (this_char == 'G') {
+          n_G += 1;
+        }
+      }
+      en(
+        "  "+
+        "A: "+Math.round((n_A * 100.0 / total_length) * Math.pow(10, 2) ) / Math.pow(10, 2)+"% "+
+        "T: "+Math.round((n_T * 100.0 / total_length) * Math.pow(10, 2) ) / Math.pow(10, 2)+"% "+
+        "C: "+Math.round((n_C * 100.0 / total_length) * Math.pow(10, 2) ) / Math.pow(10, 2)+"% "+
+        "G: "+Math.round((n_G * 100.0 / total_length) * Math.pow(10, 2) ) / Math.pow(10, 2)+"% "
+      );
+      en("");
+    }
+  }
+
+  public static void e(String i) {
+    System.out.print(i);
+  }
+
+  public static void en(String i) {
+    System.out.println(i);
+  }
+
+  public static void main(String[] args) {
+    commandline_arguments = args;
+    BaseComposition x = new BaseComposition();
+  }
+
+}