#V1 -> ; After a type-1 syllable starting with , only allow or
19 | ; (with equal probability). Equivalent to the exclusion rule ` #V1 !> `
--------------------------------------------------------------------------------
/types/types.go:
--------------------------------------------------------------------------------
1 | package types
2 |
3 | type CharSet map[string]float64
4 |
5 | type CharClass struct {
6 | List []string
7 | Weights CharSet
8 | }
9 |
10 | func (c CharClass) Contains(k string) bool {
11 | _, ok := c.Weights[k]
12 | return ok
13 | }
14 |
--------------------------------------------------------------------------------
/wordmodel/wordmodel.go:
--------------------------------------------------------------------------------
1 | package wordmodel
2 |
3 | import "time"
4 | import "strings"
5 | import "math/rand"
6 | import . "github.com/conlang-software-dev/Logopoeist/parser"
7 | import . "github.com/conlang-software-dev/Logopoeist/types"
8 | import . "github.com/conlang-software-dev/Logopoeist/interpreter"
9 | import . "github.com/conlang-software-dev/Logopoeist/environment"
10 | import . "github.com/conlang-software-dev/Logopoeist/grammar"
11 | import . "github.com/conlang-software-dev/Logopoeist/charmodel"
12 | import . "github.com/conlang-software-dev/Logopoeist/earley"
13 |
14 | type model struct {
15 | start string
16 | nextvar int
17 | env Environment
18 | synmodel Grammar
19 | chrmodel *CharModel
20 | rnd *rand.Rand
21 | words map[string]struct{}
22 | }
23 |
24 | func (m *model) addRule(svar string, n *Node) {
25 | freq := InterpretNumber(n.Right)
26 | rule := make([]*Node, 0, 10)
27 | for sn := n.Left; sn != nil; sn = sn.Right {
28 | subst := sn.Left
29 | switch subst.Type {
30 | case SVar, CVar:
31 | rule = append(rule, subst)
32 | case Class:
33 | cvar := m.env.AssignNew(subst)
34 | rule = append(rule, &Node{
35 | Type: CVar,
36 | Value: cvar,
37 | })
38 | default:
39 | panic("Invalid Node Type in Syntax Rule")
40 | }
41 | }
42 |
43 | m.synmodel.AddRule(svar, rule, freq)
44 | }
45 |
46 | func (m *model) generateNgrams(cond_n *Node) [][]string {
47 | var last_ngrams [][]string
48 |
49 | sn := cond_n
50 | if sn.Left.Type == Boundary {
51 | last_ngrams = append(last_ngrams, []string{"_"})
52 | sn = sn.Right
53 | } else {
54 | last_ngrams = append(last_ngrams, []string{})
55 | }
56 |
57 | for ; sn != nil; sn = sn.Right {
58 | cclass := m.env.GetClass(sn.Left)
59 | next_ngrams := make([][]string, 0, cap(last_ngrams)*len(cclass.List))
60 | for _, ngram := range last_ngrams {
61 | for _, chr := range cclass.List {
62 | new_ngram := append(ngram, chr)
63 | next_ngrams = append(next_ngrams, new_ngram)
64 | }
65 | }
66 | last_ngrams = next_ngrams
67 | }
68 |
69 | return last_ngrams
70 | }
71 |
72 | func (m *model) addCondition(cond_n *Node, dist_n *Node) {
73 | dist := m.env.GetClass(dist_n).Weights
74 | for _, ngchars := range m.generateNgrams(cond_n) {
75 | ngram := strings.Join(ngchars, "")
76 | m.chrmodel.AddCondition(ngram, &dist)
77 | }
78 | }
79 |
80 | func (m *model) addExclusion(cond_n *Node, dist_n *Node) {
81 | dist := m.env.GetClass(dist_n).Weights
82 | for _, ngchars := range m.generateNgrams(cond_n) {
83 | ngram := strings.Join(ngchars, "")
84 | m.chrmodel.AddExclusion(ngram, &dist)
85 | }
86 | }
87 |
88 | func (m *model) Execute(n *Node) {
89 | if n == nil || m == nil {
90 | return
91 | }
92 | switch n.Type {
93 | case Production:
94 | m.addRule(n.Left.Value, n.Right)
95 | if m.start == "" {
96 | m.start = n.Left.Value
97 | }
98 | case Definition:
99 | m.env.Assign(n.Left.Value, n.Right)
100 | case Condition:
101 | m.addCondition(n.Left, n.Right)
102 | case Exclusion:
103 | m.addExclusion(n.Left, n.Right)
104 | }
105 | }
106 |
107 | func (m *model) gen_rec(ep *EarleyParser, clist []string, min int, max int) ([]string, bool) {
108 |
109 | finalize := func() ([]string, bool) {
110 | final := clist[1:]
111 | word := strings.Join(final, "")
112 | if _, ok := m.words[word]; !ok {
113 | m.words[word] = struct{}{}
114 | return final, true
115 | }
116 | return nil, false
117 | }
118 |
119 | recurse := func() ([]string, bool) {
120 | if max > 0 && len(clist) > max {
121 | return nil, false
122 | }
123 |
124 | base := ep.AllowedTokens()
125 | dist := m.chrmodel.CalcDistribution(base, clist)
126 |
127 | total := 0.0
128 | for _, w := range dist {
129 | total += w
130 | }
131 |
132 | for len(dist) > 0 {
133 | r := m.rnd.Float64() * total
134 | for c, w := range dist {
135 | r -= w
136 | if r <= 0 {
137 | total -= w
138 | delete(dist, c)
139 |
140 | if np, ok := ep.Next(c); ok {
141 | if nclist, ok := m.gen_rec(np, append(clist, c), min, max); ok {
142 | return nclist, true
143 | }
144 | }
145 | break
146 | }
147 | }
148 | }
149 | return nil, false
150 | }
151 |
152 | if ep.IsFinished() && len(clist) > min {
153 | var attempt func() ([]string, bool)
154 | var fallback func() ([]string, bool)
155 | if m.rnd.Float64() < ep.TerminationProbability() {
156 | attempt = finalize
157 | fallback = recurse
158 | } else {
159 | attempt = recurse
160 | fallback = finalize
161 | }
162 | if nclist, ok := attempt(); ok {
163 | return nclist, true
164 | }
165 | return fallback()
166 | }
167 |
168 | return recurse()
169 | }
170 |
171 | func (m *model) Generate(min int, max int) ([]string, bool) {
172 | clist := make([]string, 1, 10)
173 | clist[0] = "_"
174 |
175 | ep := NewParser(m.env, m.synmodel, m.start)
176 | return m.gen_rec(ep, clist, min, max)
177 | }
178 |
179 | func WordModel() *model {
180 | return &model{
181 | start: "",
182 | env: make(Environment),
183 | synmodel: make(Grammar),
184 | chrmodel: NewModel(),
185 | rnd: rand.New(rand.NewSource(time.Now().UnixNano())),
186 | words: make(map[string]struct{}),
187 | }
188 | }
189 |
--------------------------------------------------------------------------------