def genDivideRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]] #divident
el2 = math2sc.variables_sc[operation[1]] #divisor
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #difference result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
#gen input sum parameters
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "произведение*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, sumNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), sumNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
def genEqualityRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
idtf = "равенство*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
eqNode = sc_utils.getElementByIdtf(idtf, segment)
if eqNode == None:
eqNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
eqNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, eqNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), eqNode,
setNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return el1
def gen_fracture_relation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen node that represents fracture
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
#find or generate ordinal fracture node
idtf = "обыкновенная дробь"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, powNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), powNode, setNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
#find or generate numerator
numIdtf = "числитель_"
numIdtf = sc_utils.utf8ToCp1251(str(numIdtf))
numNode = sc_utils.getElementByIdtf(numIdtf, segment)
if numNode == None:
numNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, numIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, numNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), numNode, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
#find or generate denominator
numIdtf = "знаменатель_"
numIdtf = sc_utils.utf8ToCp1251(str(numIdtf))
numNode = sc_utils.getElementByIdtf(numIdtf, segment)
if numNode == None:
numNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, numIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, numNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), numNode, arc2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
return setNode
def genSumRelation(session, segment, operation, _result):
"""
@param session: session
@param segment: list of segments to search objects in
@param operation: sum operation and list of operands
@param _result: a node which the result of translation
@return: a node that represents the result of summ
"""
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def gen_function(name, params, session, segment, _result):
"""
@param name: function name
@param params: list of function params
@param _result: an output node of the translator
@return:
"""
#gen function node
idtf = name + "*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
funcNode = sc_utils.getElementByIdtf(idtf, segment)
if funcNode == None:
funcNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
funcNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, funcNode,
sc.SC_CONST)
#gen args set
argsSet = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, argsSet,
sc.SC_CONST)
for x in params:
param = math2sc.variables_sc[x]
arc = sc_utils.createPair(session, core.Kernel.segment(), argsSet,
param, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, param,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc,
sc.SC_CONST)
pass
#gen relation arc
result = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
relation = sc_utils.createPair(session, core.Kernel.segment(), argsSet,
result, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
arc = sc_utils.createPair(session, core.Kernel.segment(), funcNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc,
sc.SC_CONST)
return result
def genMultiplyRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "произведение*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def genDifferenceRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]] #minuend
el2 = math2sc.variables_sc[operation[1]] #subtrahend
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #difference result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
#gen input sum parameters
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, res,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
el1, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
sumNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, sumNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), sumNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def genSumRelation(session, segment, operation, _result):
"""
@param session: session
@param segment: list of segments to search objects in
@param operation: sum operation and list of operands
@param _result: a node which the result of translation
@return: a node that represents the result of summ
"""
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "сумма*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
sumNode = sc_utils.getElementByIdtf(idtf, segment)
if sumNode == None:
sumNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, sumNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, sumNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), sumNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
def gen_function(name, params, session, segment, _result):
"""
@param name: function name
@param params: list of function params
@param _result: an output node of the translator
@return:
"""
#gen function node
idtf = name+"*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
funcNode = sc_utils.getElementByIdtf(idtf, segment)
if funcNode == None:
funcNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, funcNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, funcNode, sc.SC_CONST)
#gen args set
argsSet = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, argsSet, sc.SC_CONST)
for x in params:
param = math2sc.variables_sc[x]
arc = sc_utils.createPair(session, core.Kernel.segment(), argsSet, param, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, param, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc, sc.SC_CONST)
pass
#gen relation arc
result = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
relation = sc_utils.createPair(session, core.Kernel.segment(), argsSet, result, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
arc = sc_utils.createPair(session,core.Kernel.segment(), funcNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc, sc.SC_CONST)
return result
def genEqualityRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
idtf = "равенство*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
eqNode = sc_utils.getElementByIdtf(idtf, segment)
if eqNode == None:
eqNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, eqNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, eqNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), eqNode, setNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return el1
def gen_fracture_relation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen node that represents fracture
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#find or generate ordinal fracture node
idtf = "обыкновенная дробь"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, powNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), powNode,
setNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
#find or generate numerator
numIdtf = "числитель_"
numIdtf = sc_utils.utf8ToCp1251(str(numIdtf))
numNode = sc_utils.getElementByIdtf(numIdtf, segment)
if numNode == None:
numNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
numIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, numNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), numNode, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
#find or generate denominator
numIdtf = "знаменатель_"
numIdtf = sc_utils.utf8ToCp1251(str(numIdtf))
numNode = sc_utils.getElementByIdtf(numIdtf, segment)
if numNode == None:
numNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
numIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, numNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), numNode, arc2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
return setNode
def genPowerRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, setNode,
sc.SC_CONST)
arc1 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el1,
sc.SC_CONST)
arc2 = sc_utils.createPair(session, core.Kernel.segment(), setNode, el2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, arc2,
sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #add result node
sc_utils.createPair(session, core.Kernel.segment(), _result, res,
sc.SC_CONST)
relation = sc_utils.createPair(session, core.Kernel.segment(), setNode,
res, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relation,
sc.SC_CONST)
idtf = "возведение в степень*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param,
powNode, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, powNode,
sc.SC_CONST)
relarc = sc_utils.createPair(session, core.Kernel.segment(), powNode,
setNode, sc.SC_CONST)
baseIdtf = "основание_"
baseIdtf = sc_utils.utf8ToCp1251(str(baseIdtf))
baseNode = sc_utils.getElementByIdtf(baseIdtf, segment)
if baseNode == None:
baseNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
baseIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, baseNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), baseNode, arc1,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
expIdtf = "показатель_"
expIdtf = sc_utils.utf8ToCp1251(str(expIdtf))
expNode = sc_utils.getElementByIdtf(expIdtf, segment)
if expNode == None:
expNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
expIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, expNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), expNode, arc2,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
powerIdtf = "результат_"
powerIdtf = sc_utils.utf8ToCp1251(str(powerIdtf))
powerNode = sc_utils.getElementByIdtf(powerIdtf, segment)
if powerNode == None:
powerNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
powerIdtf)[1]
sc_utils.createPair(session, core.Kernel.segment(), _result, powerNode,
sc.SC_CONST)
a = sc_utils.createPair(session, core.Kernel.segment(), powerNode,
relation, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, a,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), _result, relarc,
sc.SC_CONST)
return res
def translate_object(_segment, _object, _type, _params):
"""Translates specified scg-object to SC-code.
@param _segment: segment to translate object in
@type _segment: sc_segment
@param _object: scg-object to translate
@type _object: SCgObject or SCgPair
@param _type: object type
@type _type: sc_type
@param _params: additional parameters to translate object. It contains list of sc-elements, that
designates semantic types for specified object. sc-element, that designate translated object will be included to
sets from _params
@type _params: list
@return: if object translated successfully, then return True, else - False
@rtype: bool
"""
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
# getting node idtf
idtf = _object.getText()
sc_object = None
el = None
isUri = False
created = False
# if idtf empty, then creating new element
if idtf is None:
el = session.create_el(_segment, _type)
created = True
else:
# encode idtf to cp1251
idtf = sc_utils.utf8ToCp1251(str(idtf))
# check if idtf if full uri
isUri = idtf.startswith('/')
# trying to find object by idtf, if it doesn't exists, then creating it
try:
if el is None:
if isUri:
el = session.find_el_full_uri(idtf)
if el is None:
el = session.create_el_full_uri(idtf, _type)[1]
created = True
else:
_segs = [_segment.get_full_uri()]
_segs.extend(env.search_segments)
# trying to find element
el = sc_utils.getElementByIdtf(idtf, _segs)
if el is None:
el = session.create_el_idtf(_segment, _type, idtf)[1]
created = True
except:
import sys, traceback
print sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
return False
assert el is not None
_object._setScAddr(el)
_object.setMerged(not created)
# including to sets for structure type
for param in _params:
sc_utils.createPairPosPerm(session, _segment, param, el, sc.SC_CONST)
return True
def generate_exppressions(_xmlnode, tag, session, segment):
"""
Process math tag. Generate relations between variables and numbers
"""
global parse_result
while len(stack) > 0:
parse_result.append(stack.pop(-1))
#generate unary expressions
for var in variables:
varname = var[0]
while len(var[1]) > 0:
op = var[1].pop(0)
expr = op + var[0]
key = var[0]
var[0] = expr
for operation in operations:
for arg in operation[1]:
if arg == key:
operation[1][operation[1].index(key)] = expr
for elem in parse_result:
if elem == key:
parse_result[parse_result.index(key)] = expr
if op == "-":
#generate unary minus relation
#find unary minus relation node, if not find create
idtf = "обратное число*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
unMinusNode = sc_utils.getElementByIdtf(idtf, segment)
if unMinusNode == None:
unMinusNode = session.create_el_idtf(
core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session,
core.Kernel.segment(),
param, unMinusNode,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el,
unMinusNode, sc.SC_CONST)
#gen node for result
varSC = variables_sc[key]
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE,
"")[1] #node for result
pair = sc_utils.createPair(
session, core.Kernel.segment(), varSC, res,
sc.SC_CONST) #arc between processed node and result
relBelong = sc_utils.createPair(session, core.Kernel.segment(),
unMinusNode, pair, sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el, res,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el, pair,
sc.SC_CONST)
sc_utils.createPair(session, core.Kernel.segment(), el,
relBelong, sc.SC_CONST)
variables_sc[expr] = res
#generate operations
expr = ""
for elem in parse_result:
if (not elem in operation_priority.keys()
and not elem in functions.keys()):
stack.append(elem)
else:
op = elem
if (op not in functions.keys()):
operand1 = stack.pop(-1)
operand2 = stack.pop(-1)
expr = operand2 + op + operand1
stack.append(expr)
if op in binary_expression_gen.keys():
gen_operation = binary_expression_gen[op]
res = gen_operation(session, segment, [operand2, operand1],
el)
variables_sc[expr] = res
else:
translation_errors.append("Unsupported operation")
else:
operands = []
expr = op + "("
for i in range(0, functions[op], 1):
operands.append(stack.pop(-1))
expr += operands[-1]
expr += ","
expr += ")"
stack.append(expr)
res = f_generator.gen_function(op, operands, session, segment,
el)
variables_sc[expr] = res
return
def genPowerRelation(session, segment, operation, _result):
el1 = math2sc.variables_sc[operation[0]]
el2 = math2sc.variables_sc[operation[1]]
#gen set of sum components
setNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, setNode, sc.SC_CONST)
arc1 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el1, sc.SC_CONST)
arc2 = sc_utils.createPair(session,core.Kernel.segment(), setNode, el2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, arc2, sc.SC_CONST)
#gen sum relations
res = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, "")[1] #add result node
sc_utils.createPair(session,core.Kernel.segment(), _result, res, sc.SC_CONST)
relation = sc_utils.createPair(session,core.Kernel.segment(), setNode, res, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relation, sc.SC_CONST)
idtf = "возведение в степень*"
idtf = sc_utils.utf8ToCp1251(str(idtf))
powNode = sc_utils.getElementByIdtf(idtf, segment)
if powNode == None:
powNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, idtf)[1]
for param in [keynodes.info.stype_bin_orient_norole_rel]:
sc_utils.createPairPosPerm(session, core.Kernel.segment(), param, powNode, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, powNode, sc.SC_CONST)
relarc = sc_utils.createPair(session,core.Kernel.segment(), powNode, setNode, sc.SC_CONST)
baseIdtf = "основание_"
baseIdtf = sc_utils.utf8ToCp1251(str(baseIdtf))
baseNode = sc_utils.getElementByIdtf(baseIdtf, segment)
if baseNode == None:
baseNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, baseIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, baseNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), baseNode, arc1, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
expIdtf = "показатель_"
expIdtf = sc_utils.utf8ToCp1251(str(expIdtf))
expNode = sc_utils.getElementByIdtf(expIdtf, segment)
if expNode == None:
expNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, expIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, expNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), expNode, arc2, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
powerIdtf = "результат_"
powerIdtf = sc_utils.utf8ToCp1251(str(powerIdtf))
powerNode = sc_utils.getElementByIdtf(powerIdtf, segment)
if powerNode == None:
powerNode = session.create_el_idtf(core.Kernel.segment(), sc.SC_NODE, powerIdtf)[1]
sc_utils.createPair(session,core.Kernel.segment(), _result, powerNode, sc.SC_CONST)
a = sc_utils.createPair(session,core.Kernel.segment(), powerNode, relation, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, a, sc.SC_CONST)
sc_utils.createPair(session,core.Kernel.segment(), _result, relarc, sc.SC_CONST)
return res
def translate_object(_segment, _object, _type, _params):
"""Translates specified scg-object to SC-code.
@param _segment: segment to translate object in
@type _segment: sc_segment
@param _object: scg-object to translate
@type _object: SCgObject or SCgPair
@param _type: object type
@type _type: sc_type
@param _params: additional parameters to translate object. It contains list of sc-elements, that
designates semantic types for specified object. sc-element, that designate translated object will be included to
sets from _params
@type _params: list
@return: if object translated successfully, then return True, else - False
@rtype: bool
"""
import suit.core.sc_utils as sc_utils
session = core.Kernel.session()
# getting node idtf
idtf = _object.getText()
sc_object = None
el = None
isUri = False
created = False
# if idtf empty, then creating new element
if idtf is None:
el = session.create_el(_segment, _type)
created = True
else:
# encode idtf to cp1251
idtf = sc_utils.utf8ToCp1251(str(idtf))
# check if idtf if full uri
isUri = idtf.startswith('/')
# trying to find object by idtf, if it doesn't exists, then creating it
try:
if el is None:
if isUri:
el = session.find_el_full_uri(idtf)
if el is None:
el = session.create_el_full_uri(idtf, _type)[1]
created = True
else:
_segs = [_segment.get_full_uri()]
_segs.extend(env.search_segments)
# trying to find element
el = sc_utils.getElementByIdtf(idtf, _segs)
if el is None:
el = session.create_el_idtf(_segment, _type, idtf)[1]
created = True
except:
import sys, traceback
print sys.exc_info()[0]
traceback.print_exc(file=sys.stdout)
return False
assert el is not None
_object._setScAddr(el)
_object.setMerged(not created)
# including to sets for structure type
for param in _params:
sc_utils.createPairPosPerm(session, _segment, param, el, sc.SC_CONST)
return True
