Morphological dictionary - Revision history

Bech: Link to French page

2014-10-06T12:04:22Z

Link to French page

Francis Tyers: /* Determinism */

2014-07-10T19:34:16Z

Determinism

Francis Tyers: /* Determinism */

2014-07-10T19:30:41Z

Determinism

Francis Tyers: /* Paradigms */

2014-05-19T23:27:57Z

Paradigms

Youssefsan: moved Morphological dictionaries to Morphological dictionary: Change title to singular.

2012-12-11T19:24:49Z

moved Morphological dictionaries to Morphological dictionary: Change title to singular.

Objectivesea: Mainly punctuation improvements; corrected apparent error in caption for ''Image:Finite-state transducer wound wounds.svg''; changed ''on the right'' to''above'' to prevent confusion

2011-12-21T22:14:02Z

Mainly punctuation improvements; corrected apparent error in caption for ''Image:Finite-state transducer wound wounds.svg''; changed ''on the right'' to''above'' to prevent confusion

Show changes

Bech: /* Determinism */ wider image

2011-12-10T22:00:11Z

Determinism: wider image

Bech: /* Acceptors */ error in a regular expression according what is said after

2011-12-10T18:42:30Z

Acceptors: error in a regular expression according what is said after

Bech: Documentation in English

2011-09-03T18:43:07Z

Documentation in English

69.107.79.172 at 23:03, 24 July 2010

2010-07-24T23:03:12Z

← Older revision		Revision as of 12:04, 6 October 2014
Line 1:		Line 1:
			[[Dictionnaire morphologique\|En français]]

	{{TOCD}}		{{TOCD}}

@@ Line 197: / Line 197: @@
                 if state not in state_output_pairs:
                         state_output_pairs[state] = set();
-                reached_states |= step(state, c);
+                reached_states = reached_states.union(step(state, c));
                 del state_output_pairs[state];

@@ Line 205: / Line 205: @@
         input += c;
-print('^' + '/'.join([input] + [analysis[0] for analysis in state_output_pairs[8]]) + '$')
+accepting_output_pairs = list(state_output_pairs[8]);
+sys.stdout.write('^' + input + '/');
+for count, analysis in enumerate(accepting_output_pairs):
+        if count == len(accepting_output_pairs) - 1:
+                sys.stdout.write(analysis[0] + '$\n');
+        else:
+                sys.stdout.write(analysis[0] + '/');
 </source>
 </div>

@@ Line 235: / Line 235: @@
 <source lang="xml">
   <pardef n="-s">
+    <e><p><l/><r><s n="n"/><S n="sg"/></r></p></e>
-    <e>
+    <e><p><l>s</l><r><s n="n"/><S n="sg"/></r></p></e>
-      <p>
-        <l/>
-        <r><s n="n"/><s n="sg"/></r>
-      </p>
-    </e>
-    <e>
-      <p>
-        <l>s</l>
-        <r><s n="n"/><s n="pl"/></r>
-      </p>
-    </e>
   </pardef>
 </source>
 </div>
 ===Sections===

@@ Line 107: / Line 107: @@
 ====Determinism====
-[[Image:Finite-state transducer wound wounds.svg|thumb|125px|right|A non-deterministic finite-state transducer for three strings: wound, wounds. ]]
+[[Image:Finite-state transducer wound wounds.svg|thumb|200px|right|A non-deterministic finite-state transducer for three strings: wound, wounds. ]]
 The transducer on the right is '''deterministic''', that is that for any given state and input symbol it can only pass on to one state, or accept. In contrast, a '''non-deterministic''' transducer (as on the right) is one which from a given state and input symbol can branch to more than one state. That is that it can take more than one path through the transducer simultaneously. Note that although the transducer on the right branches, it branches in a deterministic way, after consuming the string "beer", it can either step to <code>(s:<n>)</code> if the next input symbol is 's', or <code>(θ:<n>)</code> otherwise.

← Older revision	Revision as of 19:24, 11 December 2012
(No difference)

@@ Line 57: / Line 57: @@
 No
 </pre>
-It is worth noting that a finite-state acceptor can accept any string that can be defined by a regular expression. For example, if we want to accept the expression <code>be*r</code>, that is "b" followed by one or more "e" followed by "r" (e.g. ber, beer, beeer, ...), we could do it with a finite-state acceptor. Finite-state acceptors can be used in applications such as spell-checking, where one of the basic tasks is to check if a word exists or not in a list of words. Using an acceptor is more efficient than the equivalent list for reasons which will be outlined below.
+It is worth noting that a finite-state acceptor can accept any string that can be defined by a regular expression. For example, if we want to accept the expression <code>bee*r</code>, that can be also written <code>be+r</code>, that is "b" followed by one or more "e" followed by "r" (e.g. ber, beer, beeer, ...), we could do it with a finite-state acceptor. Finite-state acceptors can be used in applications such as spell-checking, where one of the basic tasks is to check if a word exists or not in a list of words. Using an acceptor is more efficient than the equivalent list for reasons which will be outlined below.

@@ Line 299: / Line 299: @@
 [[Category:Documentation]]
 [[Category:Theoretical background]]
+[[Category:Documentation in English]]