Susam's Java Pages

Zero Length Regular Expression

2010-05-03T00:00:00Z

This post presents a list of how zero length regular expression is handled in various tools and programming languages. All of them compile the zero length regular expression pattern and the regular expression matches all strings.

GNU grep

$ printf "foo\nbar\n" | grep ""
foo
bar

BSD grep

$ printf "foo\nbar\n" | grep ""
foo
bar

Perl

$ perl -e 'print(("foo" =~ //) . "\n")'
1

Python

$ python
Python 2.5.2 (r252:60911, Jan  4 2009, 21:59:32)
[GCC 4.3.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import re; re.compile('').search('foo')
<_sre.SRE_Match object at 0x7fc6c5a2c510>

Java

$ cat RegexExperiment.java
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexExperiment
{
    public static void main(String[] args)
    {
        System.out.println(Pattern.compile("").matcher("foo").find());
    }
}
$ javac RegexExperiment.java && java RegexExperiment
true

MzScheme

$ mzscheme
Welcome to MzScheme v4.0.1 [3m], Copyright (c) 2004-2008 PLT Scheme Inc.
> (regexp-match "" "foo")
("")

CLISP

$ clisp
  i i i i i i i       ooooo    o        ooooooo   ooooo   ooooo
  I I I I I I I      8     8   8           8     8     o  8    8
  I  \ `+' /  I      8         8           8     8        8    8
   \  `-+-'  /       8         8           8      ooooo   8oooo
    `-__|__-'        8         8           8           8  8
        |            8     o   8           8     o     8  8
  ------+------       ooooo    8oooooo  ooo8ooo   ooooo   8

Welcome to GNU CLISP 2.44.1 (2008-02-23) <http://clisp.cons.org/>

Copyright (c) Bruno Haible, Michael Stoll 1992, 1993
Copyright (c) Bruno Haible, Marcus Daniels 1994-1997
Copyright (c) Bruno Haible, Pierpaolo Bernardi, Sam Steingold 1998
Copyright (c) Bruno Haible, Sam Steingold 1999-2000
Copyright (c) Sam Steingold, Bruno Haible 2001-2008

Type :h and hit Enter for context help.

[1]> (regexp:match "" "foo")
#S(REGEXP:MATCH :START 0 :END 0)

C

$ ls -l /usr/lib/libpcre.so*
lrwxrwxrwx 1 root root     17 May  3 15:15 /usr/lib/libpcre.so -> libpcre.so.3.12.1
lrwxrwxrwx 1 root root     17 Jan  6 14:57 /usr/lib/libpcre.so.3 -> libpcre.so.3.12.1
-rw-r--r-- 1 root root 162816 Jul 14  2008 /usr/lib/libpcre.so.3.12.1
susam@swift:~$ cat pcre.c
#include <stdio.h>
#include <string.h>
#include <pcre.h>

#include <stdio.h>
#include <string.h>
#include <pcre.h>

int main(int argc, char **argv)
{
    pcre *p;
    char *re = "";
    char *s  = "foo";
    const char *errmsg;
    int errpos;
    int ovector[10];
    int ret;

    p = pcre_compile(re, 0, &errmsg, &errpos, NULL);
    ret = pcre_exec(p, NULL, s, strlen(s), 0, 0,
                    ovector, sizeof ovector / sizeof *ovector);

    printf(ret < 0 ? "no match\n" : "match\n");
}
$ cc -lpcre pcre.c && ./a.out
match

Lucene Java Example

2010-04-10T00:00:00Z

Here is a simple program I wrote that makes use of Lucene Java 3.0.1:

package in.susam;

import java.io.File;
import java.io.IOException;

import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.util.Version;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;

public class LuceneDemo
{
    static final String INDEX_DIR = "index1";

    public static void main(String[] args) throws Exception {
        write();
        search("content", "integer");
        search("tags", "rhyme");
    }

    static void write() throws IOException {
        // Create index
        IndexWriter writer = new IndexWriter(
                FSDirectory.open(new File(INDEX_DIR)),
                new StandardAnalyzer(Version.LUCENE_30),
                true,
                IndexWriter.MaxFieldLength.UNLIMITED);

        Document doc;
        String field;
        String text;

        // Add first document
        doc = new Document();

        field = "title";
        text = "Humpty Dumpty sat on a wall";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        field = "content";
        text = "Humpty Dumpty sat on a wall.\n" +
               "Humpty Dumpty had a great fall;\n" +
               "All the King's horses and all the King's men,\n" +
               "Couldn't put Humpty together again.";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        field = "tags";
        text = "rhyme";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        writer.addDocument(doc);

        // Add second document
        doc = new Document();

        field = "title";
        text = "Jack and Jill went up the hill";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        field = "content";
        text = "Jack and Jill went up the hill\n" +
               "To fetch a pail of water.\n" +
               "Jack fell down and broke his crown,\n" +
               "And Jill came tumbling after.\n";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        field = "tags";
        text = "rhyme";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        writer.addDocument(doc);

        // Add third document
        doc = new Document();

        field = "title";
        text = "Fermat's Last Theorem";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        field = "content";
        text = "In number theory, Fermat's Last Theorem states that no " +
               "three positive integers a, b and c can satisfy the " +
               "equation for a^n + b^n = c^n for any integer value of n " +
               "greater than two.";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        field = "tags";
        text = "math, theorem";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        writer.addDocument(doc);

        // Add fourth document
        doc = new Document();

        field = "title";
        text = "Euler's theorem";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        field = "content";
        text = "Euler's theorem states that if n is a positive integer and " +
               "a is a positive integer coprime to n, then a^phi(n) = 1 " +
               "(mod n) where phi(n) is Euler's totient function.";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        field = "tags";
        text = "math, theorem";
        doc.add(new Field(field, text, Field.Store.YES, Field.Index.ANALYZED));

        writer.addDocument(doc);

        writer.close();
    }

    static void search(String field, String query) throws IOException,
                                                          ParseException {
        IndexSearcher searcher = new IndexSearcher(
                FSDirectory.open(new File(INDEX_DIR)), true);
        QueryParser parser = new QueryParser(
                Version.LUCENE_30, field,
                new StandardAnalyzer(Version.LUCENE_30));
        TopDocs docs = searcher.search(parser.parse(query), 10);
        System.out.println("Query: '" + query + "' in '" + field + "'");
        System.out.println("Total hits: " + docs.totalHits);
        System.out.println("");
        for (int i = 0; i < docs.scoreDocs.length; i++) {
            ScoreDoc hit = docs.scoreDocs[i];
            Document doc = searcher.doc(hit.doc);
            System.out.println("#" + i);
            System.out.println("title: " + doc.get("title"));
            System.out.println("content: " + doc.get("content"));
            System.out.println("tags: " + doc.get("tags"));
            System.out.println("id: " + hit.doc);
            System.out.println("score: " + hit.score);
            System.out.println();
        }
    }
}

Here is the output when the above code is compiled and run:

Query: 'integer' in 'content'
Total hits: 2

#0
title: Euler's theorem
content: Euler's theorem states that if n is a positive integer and a is a positive integer coprime to n, then a^phi(n) = 1 (mod n) where phi(n) is Euler's totient function.
tags: math, theorem
id: 3
score: 0.34144828

#1
title: Fermat's Last Theorem
content: In number theory, Fermat's Last Theorem states that no three positive integers a, b and c can satisfy the equation for a^n + b^n = c^n for any integer value of n greater than two.
tags: math, theorem
id: 2
score: 0.24144039

Query: 'rhyme' in 'tags'
Total hits: 2

#0
title: Humpty Dumpty sat on a wall
content: Humpty Dumpty sat on a wall.
Humpty Dumpty had a great fall;
All the King's horses and all the King's men,
Couldn't put Humpty together again.
tags: rhyme
id: 0
score: 1.287682

#1
title: Jack and Jill went up the hill
content: Jack and Jill went up the hill
To fetch a pail of water.
Jack fell down and broke his crown,
And Jill came tumbling after.

tags: rhyme
id: 1
score: 1.287682

Read on website | #java | #programming | #technology

ResizableDoubleArray contract() and expand()

2010-03-23T00:00:00Z

Here is a diff of the changes I made to Apache Common Math's ResizableDoubleArray class to investigate how it contracts or expands its internal capacity.

Index: src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java
===================================================================
--- src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java (revision 925455)
+++ src/main/java/org/apache/commons/math/util/ResizableDoubleArray.java (working copy)
@@ -157,6 +157,14 @@
     public ResizableDoubleArray(int initialCapacity) {
         setInitialCapacity(initialCapacity);
         internalArray = new double[this.initialCapacity];
+        System.out.println(":::: initialCapacity: " + initialCapacity);
+        System.out.println(":::: expansionMode: " +
+                           (expansionMode == 0 ? "MULTIPLICATIVE_MODE"
+                                               : "ADDITIVE_MODE" ));
+        System.out.println(":::: expansionFactor: " + expansionFactor);
+        System.out.println(":::: contractionCriteria: " +
+                           contractionCriteria);
+        System.out.println();
     }

     /**
@@ -264,14 +272,33 @@
      * @param value to be added to end of array
      */
     public synchronized void addElement(double value) {
+        System.out.println(":::: addElement(" + value + ")");
+        System.out.println(":::: startIndex: " + startIndex);
+        System.out.println(":::: internalArray.length: " +
+                           internalArray.length);
         numElements++;
+        System.out.println(":::: numElements incremented to: " +
+                           numElements);
+
         if ((startIndex + numElements) > internalArray.length) {
+            System.out.println(":::: expanding ...");
             expand();
+            System.out.println(":::: expanded; internalArray.length: " +
+                               internalArray.length);
         }
         internalArray[startIndex + (numElements - 1)] = value;
+        System.out.print(":::: internalArray: ");
+        for (int i = 0; i < startIndex + numElements; i++) {
+            System.out.print(internalArray[i] + ", ");
+        }
+        System.out.println();
         if (shouldContract()) {
+            System.out.println(":::: contracting ...");
             contract();
+            System.out.println(":::: contracted; internalArray.length: " +
+                               internalArray.length);
         }
+        System.out.println();
     }

     /**

Here is a tiny test program to use ResizableDoubleArray.

import org.apache.commons.math.util.ResizableDoubleArray;

public class RDAContractExpand
{
    public static void main(String[] args)
    {
        ResizableDoubleArray rda = new ResizableDoubleArray(10);
        for (int i = 0; i < 10; i++)
            rda.addElement(i);
    }
}

Here is the output of the above program:

:::: initialCapacity: 10
:::: expansionMode: MULTIPLICATIVE_MODE
:::: expansionFactor: 2.0
:::: contractionCriteria: 2.5

:::: addElement(0.0)
:::: startIndex: 0
:::: internalArray.length: 10
:::: numElements incremented to: 1
:::: internalArray: 0.0,
:::: contracting ...
:::: contracted; internalArray.length: 2

:::: addElement(1.0)
:::: startIndex: 0
:::: internalArray.length: 2
:::: numElements incremented to: 2
:::: internalArray: 0.0, 1.0,

:::: addElement(2.0)
:::: startIndex: 0
:::: internalArray.length: 2
:::: numElements incremented to: 3
:::: expanding ...
:::: expanded; internalArray.length: 4
:::: internalArray: 0.0, 1.0, 2.0,

:::: addElement(3.0)
:::: startIndex: 0
:::: internalArray.length: 4
:::: numElements incremented to: 4
:::: internalArray: 0.0, 1.0, 2.0, 3.0,

:::: addElement(4.0)
:::: startIndex: 0
:::: internalArray.length: 4
:::: numElements incremented to: 5
:::: expanding ...
:::: expanded; internalArray.length: 8
:::: internalArray: 0.0, 1.0, 2.0, 3.0, 4.0,

:::: addElement(5.0)
:::: startIndex: 0
:::: internalArray.length: 8
:::: numElements incremented to: 6
:::: internalArray: 0.0, 1.0, 2.0, 3.0, 4.0, 5.0,

:::: addElement(6.0)
:::: startIndex: 0
:::: internalArray.length: 8
:::: numElements incremented to: 7
:::: internalArray: 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0,

:::: addElement(7.0)
:::: startIndex: 0
:::: internalArray.length: 8
:::: numElements incremented to: 8
:::: internalArray: 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0,

:::: addElement(8.0)
:::: startIndex: 0
:::: internalArray.length: 8
:::: numElements incremented to: 9
:::: expanding ...
:::: expanded; internalArray.length: 16
:::: internalArray: 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,

:::: addElement(9.0)
:::: startIndex: 0
:::: internalArray.length: 16
:::: numElements incremented to: 10
:::: internalArray: 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0,

Read on website | #java | #programming | #technology