summaryrefslogtreecommitdiff
path: root/lexicon.py
blob: cd6d90ab0510a3cbb8932fc83367291b31215119 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
from grammar import *
from numpy.random import choice, seed

class Lexicon(object):

	def __init__(self):
		self.categories = []

	def populate(self, grammar, number_categories=0):
		for x in range(number_categories):
			lexeme = self.makeLexeme(grammar)
			lexeme.label = self.nextLabel()
			self.categories.append(lexeme)

	def addLexeme(self, grammar, lexeme=None):
		if lexeme == None:
			lexeme = self.makeLexeme(grammar)
		lexeme.label = self.nextLabel()
		self.categories.append(lexeme)

	def makeLexeme(self, grammar):
		cadence = grammar.phonology.makeCadence()
		anticipation = grammar.morphology.selectAnticipation()
		prolongation = grammar.morphology.selectProlongation()
		lexeme = Lexeme(cadence, anticipation, prolongation)
		return lexeme

	def selectLexeme(self, index=None):
		if index == None:
			lexeme = choice(self.categories)
		else:
			lexeme = self.categories[index]
		return lexeme

	def nextLabel(self):
		nextLabel = 0
		if len(self.categories) > 0:
			nextLabel = self.categories[-1].label + 1
		return nextLabel

	def print(self):
		for i, lex in enumerate(self.categories):
			print('Lexeme', str(i))
			print('--------')
			lex.print()
			print()


class Lexeme(object):
	"""the specification of an dependant and its agreement"""
	def __init__(self, cadence, anticipation=None, prolongation=None):
		self.cadence = cadence

		# projections
		self.anticipation = anticipation
		self.prolongation = prolongation

		# dependents
		self.antecedents = []
		self.consequents = []

		self.label = 'unlabeled'

	def print(self):
		print("\n"+str(self.label))
		self.cadence.print()
		print("anticipation:", self.anticipation)
		print("prolongation:", self.prolongation)
		print("antecedents:", self.antecedents)
		print("consequents:", self.consequents)

	def addAntecedent(self, category):
		self.antecedents.append(category)
		return self

	def addConsequent(self, category):
		self.consequents.append(category)
		return self

	def addAnticipation(self, projection):
		self.anticipations.append(projection)
		return self

	def addProlongation(self, projection):
		self.prolongations.append(projection)
		return self


	def selectAntecedent(self):
		antecedent = None
		if len(self.antecedents>0):
			antecedent = choice(self.antecedents)
		return antecedent

	def selectConsequent(self):
		consequent = None
		if len(self.consequents>0):
			consequent = choice(self.consequents)
		return consequent

	def selectAnticipation(self):
		anticipation = None
		if len(self.anticipations>0):
			anticipation = choice(self.anticipations)
		return anticipation

	def selectProlongation(self):
		prolongation = None
		if len(self.prolongations>0):
			prolongation = choice(self.prolongations)
		return prolongation