Merge branch 'algorithmsforRAs'

Author: cesine

.gitignore

@@ -1,12 +1,18 @@
+# Build/IDE temp files #
+#############
 .project
 .settings
 .classpath
-
-# compiled files
 bin
 gen/srt
 build
+.RData
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
 
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
 
 # Big files #
 #############
@@ -49,6 +55,8 @@ target
 *.gz
 *.iso
 *.jar
+*.war
+*.ear
 *.rar
 *.tar
 #*.zip
@@ -63,6 +71,7 @@ bower_components
 
 # OS generated files #
 ######################
+.DS_Store
 .DS_Store?
 ehthumbs.db
 Icon?

Gruntfile.js

@@ -9,7 +9,7 @@ module.exports = function(grunt) {
     banner: '/*! <%= pkg.name %> - v<%= pkg.version %> - ' +
       '<%= grunt.template.today("yyyy-mm-dd") %>\n' +
       '<%= pkg.homepage ? "* " + pkg.homepage + "\\n" : "" %>' +
-      '* Copyright (c) <%= grunt.template.today("yyyy") %> <%= pkg.author.name %>;' +
+      '* Copyright (c) 2010-<%= grunt.template.today("yyyy") %> <%= pkg.author.name %>;' +
       ' Licensed <%= _.pluck(pkg.licenses, "type").join(", ") %> */\n',
     // Task configuration.
     concat: {
@@ -99,4 +99,4 @@ module.exports = function(grunt) {
   grunt.registerTask('docs', ['jsdoc']);
   grunt.registerTask('default', ['jshint', 'jasmine_node', 'concat', 'uglify']);
 
-};
+};

LICENSE

@@ -1,4 +1,4 @@
-Copyright 2010-2013 cesine, hisakonog
+Copyright 2010-2015 cesine, hisakonog, vronvali
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -10,4 +10,4 @@ Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
-limitations under the License.
+limitations under the License.

README.md

@@ -90,5 +90,5 @@ Groovy Syntax highlighting using Eclipse
 
 
 ## License
-Copyright (c) 2010-2013 cesine, hisakonog
+Copyright (c) 2010-2015 cesine, hisakonog, vronvali
 Licensed under the Apache 2.0 license.

bower.json

@@ -4,7 +4,8 @@
   "homepage": "https://github.com/cesine/ToolsForFieldLinguistics",
   "authors": [
     "cesine <[email protected]>",
-    "hisakonog <[email protected]>"
+    "hisakonog <[email protected]>",
+    "vronvali <[email protected]>"
   ],
   "description": "A collection of scripts and recipes for fieldlinguistics",
   "main": "dist/tools-for-field-linguistics.min.js",

src/japegrammars/ReadingList.jape

@@ -1,6 +1,6 @@
 /*
 *
-   Copyright 2011 Gina Cook
+   Copyright 2011 Gina
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

src/java/BinaryArithmetic.java

@@ -0,0 +1,104 @@
+import java.util.Arrays;
+
+/** 
+ *
+ * Location https://coderpad.io/WGT7MX76 
+ * 
+ * Example showing how to work with two arrays which need
+ * to be aligned at their ends (not starts), and where the 
+ * result of the current might affect the next.
+ *
+ * Useful for:
+ *  - binary arithmetic ("101" "010" -> "111" OR "101" "011" -> "1000")
+ *  - iterating through arrays of json where the following item might affect the result of the previous (a carry behavior)
+ */
+public class BinaryArithmetic {
+
+  /**
+   * minimal time is going to be max length of one of the string 
+   * x3 because of 
+   *  - initialization and 
+   *  - actual computation loop
+   *  - conversion to string
+   */
+  static String addBinaryStrings(String a, String b) throws Exception {
+    if (a == null) {
+      a = "0";
+    }
+    if (b == null) {
+      b = "0";
+    }
+    int alength = a.length();
+    int blength = b.length();
+
+    int maxLength = Math.max(alength, blength);
+    if (maxLength == 0) {
+      return "0";
+    }
+    int[] result = new int[maxLength]; // initialize? 
+
+    System.out.println("Padding inputs to a max length of " + maxLength);
+    for (int i = 0; i < maxLength - alength; i++) {
+      a = "0" + a;
+    }
+    for (int i = 0; i < maxLength - blength; i++) {
+      b = "0" + b;
+    }
+    System.out.println("  padded a:" + a);
+    System.out.println("  padded b:" + b);
+
+    // Initialize the results
+    for (int i = 0; i < maxLength; i++) {
+      result[i] = 0;
+    }
+
+    //keep track of the carry
+    int carry = 0;
+    for (int current = maxLength - 1; current >= 0; current--) {
+      System.out.println("Working on " + current);
+      char acurrent = a.charAt(current);
+      char bcurrent = b.charAt(current);
+
+      System.out.println("Sum of " + acurrent + " + " + bcurrent + " =");
+      int sum = addChar(acurrent, bcurrent) + carry;
+      System.out.println("     = " + sum);
+      if (sum == 3) {
+        result[current] = 1;
+        carry = 1;
+        System.out.println(" Carrying further " + carry);
+      } else if (sum == 2) {
+        result[current] = 0;
+        carry = 1;
+        System.out.println(" Carrying " + carry);
+      } else {
+        result[current] = sum;
+        carry = 0;
+      }
+    }
+
+    String asString = "";
+    if (carry == 1) {
+      asString += "1";
+    }
+    for (int i = 0; i < maxLength; i++) {
+      asString += result[i];
+    }
+    return asString;
+  }
+
+  static int addChar(char a, char b) throws Exception {
+    if ((a != '0' && a != '1') || (b != '0' && b != '1')) {
+      throw new Exception("Invalid input, use 0 or 1");
+    }
+
+    if (a == '0' && b == '0') {
+      return 0;
+    } else if (a == '0' && b == '1' || a == '1' && b == '0') {
+      return 1;
+    } else if (a == '1' && b == '1') {
+      return 2;
+    }
+    return 0;
+  }
+
+}

src/java/BinaryArithmeticTest.java

@@ -0,0 +1,85 @@
+public class BinaryArithmeticTest {
+
+  public static void itShouldBeAbleToAddBinaryStrings() throws Exception {
+    String result = BinaryArithmetic.addBinaryStrings("0", "0");
+    System.out.println(" Added strings 0 and 0 :" + result + ":");
+    assert result != null;
+    assert "0".equals(result);
+
+    result = BinaryArithmetic.addBinaryStrings("0000", "0");
+    System.out.println(" should pad the result to the size of the input :" + result + ":");
+    assert "0000".equals(result);
+
+    result = BinaryArithmetic.addBinaryStrings("", "0");
+    System.out.println(" should pad the result to the size of the input :" + result + ":");
+    assert "0".equals(result);
+
+    result = BinaryArithmetic.addBinaryStrings("", "");
+    System.out.println(" should pad the result to the size of the input :" + result + ":");
+    assert "0".equals(result);
+
+    result = BinaryArithmetic.addBinaryStrings(null, "");
+    System.out.println(" should pad the result to the size of the input :" + result + ":");
+    assert "0".equals(result);
+  }
+
+  public static void itShouldBeAbleToAddBinaryStringsWhichRequireNoCarrying() throws Exception {
+    String result = BinaryArithmetic.addBinaryStrings("101", "010");
+    System.out.println(" Added strings 101 and 010 :" + result + ":");
+    assert "111".equals(result);
+  }
+
+  public static void itShouldBeAbleToAddBinaryStringsWhichRequireCarrying() throws Exception {
+    String result = BinaryArithmetic.addBinaryStrings("101", "011");
+    System.out.println(" Added strings 101 and 011 :" + result + ":");
+    assert "1000".equals(result);
+
+    result = BinaryArithmetic.addBinaryStrings("111", "1");
+    System.out.println(" Added strings 111 and 1 :" + result + ":");
+    assert "1000".equals(result);
+
+     result = BinaryArithmetic.addBinaryStrings("111", "11");
+    System.out.println(" Added strings 111 and 11 :" + result + ":");
+    assert "1010".equals(result);
+  }
+
+  public static void itShouldBeAbleToAddChar() throws Exception {
+    int result = BinaryArithmetic.addChar('0', '0');
+    System.out.println(" Added chars 0 and 0: " + result);
+    assert result == 0;
+
+    result = BinaryArithmetic.addChar('0', '1');
+    System.out.println(" Added chars 0 and 1: " + result);
+    assert result == 1;
+
+    result = BinaryArithmetic.addChar('1', '1');
+    System.out.println(" Added chars 1 and 1: " + result);
+    assert result == 2;
+
+    try {
+      System.out.println(" Adding chars e and 1: " + result);
+      result = BinaryArithmetic.addChar('d', '1');
+      assert result == 0;
+      assert false;
+    } catch (Exception e) {
+      System.out.println("   should throw an exception ");
+      assert true;
+    }
+  }
+
+  public static void main(String[] args) {
+    System.out.println("\nRunning specs for BinaryArithmetic: ");
+
+    try {
+      itShouldBeAbleToAddBinaryStrings();
+      itShouldBeAbleToAddChar();
+      itShouldBeAbleToAddBinaryStringsWhichRequireNoCarrying();
+      itShouldBeAbleToAddBinaryStringsWhichRequireCarrying();
+    } catch (Exception e) {
+      System.out.println("Unexpected error in itShouldBeAbleToAddChar." + e);
+    }
+
+    System.out.println("\nDone \n\n");
+  }
+
+}