Lttoolbox API examples - Revision history

Francis Tyers: /* Basic example */

2017-07-05T07:59:46Z

Basic example

Bech: Link to French page

2014-10-07T12:59:34Z

Link to French page

Bech: Category:Documentation in English

2012-03-30T11:49:54Z

Category:Documentation in English

Francis Tyers: /* Basic example */ pool no longer used

2012-02-19T00:26:18Z

Basic example: pool no longer used

Francis Tyers: /* Using regular expressions */

2012-02-19T00:23:51Z

Using regular expressions

Francis Tyers: /* Writing/reading several transducers to the same file */

2011-11-14T11:59:33Z

Writing/reading several transducers to the same file

Francis Tyers: /* Writing/reading several transducers to the same file */

2011-10-18T19:55:08Z

Writing/reading several transducers to the same file

Francis Tyers at 09:39, 18 October 2011

2011-10-18T09:39:00Z

Francis Tyers: moved Basic lttoolbox example to Lttoolbox API examples

2011-10-18T09:37:46Z

moved Basic lttoolbox example to Lttoolbox API examples

Francis Tyers at 20:39, 10 October 2011

2011-10-10T20:39:30Z

@@ Line 82: / Line 82: @@
   //Rather than try to convert between Transducer and TransExe, we'll
   //just write and read.
   FILE* fst=fopen("beer.fst", "w");
+  Compression::wstring_write(L"ber", fst);   //write letters
-  t.write(fst);
+  alphabet.write(fst); // write multichars
+  Compression::multibyte_write(1, fst); // write num. fsts
+  Compression::wstring_write(L"main", fst);  // write name of first fst
+  t.write(fst); // write fst
   fclose(fst);
   fst=fopen("beer.fst", "r");

@@ Line 1: / Line 1: @@
+[[Exemple d'application Lttoolbox]]
 {{TOCD}}
 ==Basic example==

← Older revision		Revision as of 11:49, 30 March 2012
Line 368:		Line 368:

	[[Category:Lttoolbox]]		[[Category:Lttoolbox]]
			[[Category:Documentation in English]]

@@ Line 25: / Line 25: @@
 // Alphabet class
 #include <lttoolbox/alphabet.h>
-// Pool class
-#include <lttoolbox/pool.h>
 // State class
@@ Line 92: / Line 89: @@
   fclose(fst);
+  State *initial_state = new State();
-  Pool<vector<int> > *pool = new Pool<vector<int> >(1, vector<int>(50));
-  State *initial_state = new State(pool);
   initial_state->init(te.getInitial());
   State current_state = *initial_state;

@@ Line 292: / Line 292: @@
 #include <lttoolbox/transducer.h>
 #include <lttoolbox/alphabet.h>
-#include <lttoolbox/pool.h>
 #include <lttoolbox/state.h>
 #include <lttoolbox/regexp_compiler.h>

@@ Line 272: / Line 272: @@
   return 0;
 }
+</pre>
+==Using regular expressions==
+<pre>
+/*
+ * g++ -o lt-regexp lt-regexp.cc -I/usr/include/libxml2 -I/home/fran/local/include/lttoolbox-3.2 -L/home/fran/local/lib -llttoolbox3 -llibxml2
+ */
+#include <cwchar>
+#include <cstdio>
+#include <cerrno>
+#include <string>
+#include <iostream>
+#include <list>
+#include <set>
+#include <lttoolbox/ltstr.h>
+#include <lttoolbox/lt_locale.h>
+#include <lttoolbox/transducer.h>
+#include <lttoolbox/alphabet.h>
+#include <lttoolbox/pool.h>
+#include <lttoolbox/state.h>
+#include <lttoolbox/regexp_compiler.h>
+#include <lttoolbox/match_exe.h>
+#include <lttoolbox/match_state.h>
+#include <lttoolbox/xml_parse_util.h>
+wstring ws(char *arg)
+{
+  wchar_t buf[1024];
+  memset(buf, '\0', 1024);
+  size_t num_chars = mbstowcs(buf, arg, strlen(arg));
+  wstring ws(buf, num_chars);
+  return ws;
+}
+bool match(Transducer t, wstring str, Alphabet a)
+{
+  map<int, int> finals;
+  for(int i = 0; i < t.size(); i++)
+  {
+    if(!t.isFinal(i))
+    {
+      continue;
+    }
+    finals[i] = i;
+  }
+  MatchExe me(t, finals);
+  MatchState ms;
+  ms.clear();
+  ms.init(me.getInitial());
+  for(wstring::iterator it = str.begin(); it != str.end(); it++)
+  {
+    wcout << ms.size() << " " << *it << endl;
+    ms.step(a(*it, *it));
+  }
+  int val = ms.classifyFinals(me.getFinals());
+  fwprintf(stdout, L"%d\n", val);
+  if(val != -1)
+  {
+    return true;
+  }
+  return false;
+}
+int main (int argc, char** argv)
+{
+  Alphabet alphabet;
+  Transducer t;
+  RegexpCompiler re;
+  bool matched;
+  LtLocale::tryToSetLocale();
+  if(argc < 3)
+  {
+    wcout << L"Usage: lt-regexp <pattern> <string to match>" << endl;
+    exit(-1);
+  }
+  FILE *output = stdout;
+  wstring pattern = ws(argv[1]);
+  wstring s = ws(argv[2]);
+  re.initialize(&alphabet);
+  re.compile(pattern);
+  t = re.getTransducer();
+  t.minimize();
+  t.show(alphabet, output);
+  matched = match(t, s, alphabet);
+  wcout << endl << pattern << " " << s << endl;
+}
 </pre>

@@ Line 1: / Line 1: @@
+{{TOCD}}
+==Basic example==
 This is a simple C++/lttoolbox version of the 'beer' program in [[Morphological dictionaries]]
@@ Line 170: / Line 173: @@
 </pre>
+==Writing/reading several transducers to the same file==
+<pre>
+// g++ -o test test.cc -I/home/fran/local/include/lttoolbox-3.2 -L/home/fran/local/lib -llttoolbox3
+#include <cwchar>
+#include <cstdio>
+#include <iostream>
+#include <set>
+#include <lttoolbox/ltstr.h>
+#include <lttoolbox/lt_locale.h>
+#include <lttoolbox/transducer.h>
+#include <lttoolbox/alphabet.h>
+#include <lttoolbox/regexp_compiler.h>
+#include <lttoolbox/compression.h>
+int main (int argc, char** argv)
+{
+  map<int, Transducer> patterns;
+  Alphabet a;
+  RegexpCompiler re;
+  LtLocale::tryToSetLocale();
+  FILE *output = stdout;
+  FILE *fst = fopen(argv[1], "w+");
+  // Build transducers
+  a.includeSymbol(L"<n>");
+  re.initialize(&a);
+  re.compile(L"foo");
+  patterns[1] = re.getTransducer();
+  re.initialize(&a);
+  re.compile(L"bar");
+  patterns[2] = re.getTransducer();
+  re.initialize(&a);
+  re.compile(L"baz");
+  patterns[3] = re.getTransducer();
+  // Write out the transducers
+  a.write(fst);
+  Compression::multibyte_write(patterns.size(), fst);
+  fwprintf(output, L"Patterns: %d, Alphabet: %d\n", patterns.size(), a.size());
+  for(map<int, Transducer>::iterator it = patterns.begin(); it != patterns.end(); it++)
+  {
+    wchar_t buf[50];
+    memset(buf, '\0', sizeof(buf));
+    swprintf(buf, 50, L"%d", it->first);
+    wstring id(buf);
+    fwprintf(output, L"= %S =============================\n", id.c_str());
+    it->second.show(a, output);
+    Compression::wstring_write(id, fst);
+    it->second.write(fst);
+  }
+  fclose(fst);
+  fwprintf(output, L"\n\n");
+  // Now read in the transducers that we have written out, one by one.
+  FILE *new_fst = fopen(argv[1], "r");
+  Alphabet new_alphabet;
+  map<wstring, Transducer> transducers;
+  new_alphabet.read(new_fst);
+  int len = Compression::multibyte_read(new_fst);
+  while(len > 0)
+  {
+    int len2 = Compression::multibyte_read(new_fst);
+    wstring name = L"";
+    while(len2 > 0)
+    {
+      name += static_cast<wchar_t>(Compression::multibyte_read(new_fst));
+      len2--;
+    }
+    transducers[name].read(new_fst);
+    len--;
+  }
+  fwprintf(output, L"Patterns: %d, Alphabet: %d\n", transducers.size(), new_alphabet.size());
+  for(map<wstring, Transducer>::iterator it = transducers.begin(); it != transducers.end(); it++)
+  {
+    fwprintf(output, L"= %S =============================\n", it->first.c_str());
+    it->second.minimize();
+    it->second.show(a, output);
+  }
+  fclose(new_fst);
+  return 0;
+}
+</pre>
+</pre>
 [[Category:Lttoolbox]]

← Older revision	Revision as of 09:37, 18 October 2011
(No difference)

@@ Line 143: / Line 143: @@
 }
 </pre>
+[[File:Ltbeer.png|center]]
 we can simplify the building of the transducers like this:
@@ Line 167: / Line 169: @@
   t.setFinal(beerpl);
 </pre>
 [[Category:Lttoolbox]]