pyemaps 2.0.0__py3-none-any.whl

pyemaps/CifFile/drel/drel_lex.py

@@ -0,0 +1,228 @@
+#Attempt to implement dREL using PLY (Python Lex Yacc)
+from __future__ import print_function
+import ply.lex as lex
+import re    #for multiline flag
+
+states = (
+    ('paren','inclusive'),
+    )
+
+tokens = (
+    'SHORTSTRING',
+    'LONGSTRING',
+    'INTEGER',
+    'BININT',
+    'HEXINT',
+    'OCTINT',
+    'REAL',
+    'POWER',
+    'ISEQUAL',
+    'NEQ',
+    'GTE',
+    'LTE',
+    'IMAGINARY',
+    'ID',            #variable name
+    'ITEM_TAG',      #cif item as variable
+    'COMMENT',
+    'STRPREFIX',
+    'ELLIPSIS',
+    'AND',
+    'BADAND',
+    'OR',
+    'BADOR',
+    'IN',
+    'NOT',
+    'DO',
+    'FOR',
+    'LOOP',
+    'REPEAT',
+    'AS',
+    'WITH',
+    'WHERE',
+    'ELSEIF',
+    'ELSE',
+    'BREAK',
+    'NEXT',
+    'IF',
+    'SWITCH',
+    'CASE',
+    'DEFAULT',
+    'AUGOP',
+    'PRINT',
+    'FUNCTION',
+    'NEWLINE',
+    'ESCAPE_NEWLINE',
+    'OPEN_PAREN',
+    'CLOSE_PAREN'
+     )
+
+literals = '+*-/;[],:^<>{}=.`&|'  #'&' and '|' are pycifrw extensions
+t_INITIAL_ignore = ' \t'
+t_paren_ignore = ' \t\n'
+
+def t_error(t):
+    print('Illegal character %s' % repr(t.value[0]))
+
+t_POWER = r'\*\*'
+t_ISEQUAL = r'=='
+t_NEQ = r'!='
+t_GTE = r'>='
+t_LTE = r'<='
+t_ELLIPSIS = r'\.\.\.'
+t_BADOR = r'\|\|'
+t_BADAND = r'&&'
+
+def t_AUGOP(t):
+    r'(\+\+=)|(\+=)|(-=)|(--=)|(\*=)|(/=)'
+    return t
+
+# We do not have this as a literal so that we can switch to ignoring newlines
+def t_INITIAL_OPEN_PAREN(t):
+    r'\('
+    t.lexer.paren_level = 1
+    t.lexer.begin('paren')
+    return t
+
+def t_paren_OPEN_PAREN(t):
+    r'\('
+    t.lexer.paren_level +=1
+    return t
+
+def t_paren_CLOSE_PAREN(t):
+    r'\)'
+    t.lexer.paren_level -=1
+    if t.lexer.paren_level == 0:
+        t.lexer.begin('INITIAL')
+    return t
+
+# Do the reals before the integers, otherwise the integer will
+# match the first part of the real
+#
+def t_IMAGINARY(t):
+    r'(((([0-9]+[.][0-9]*)|([.][0-9]+))([Ee][+-]?[0-9]+)?)|([0-9]+))[jJ]'
+    return t
+
+def t_REAL(t):
+    r'(([0-9]+[.][0-9]*)|([.][0-9]+))([Ee][+-]?[0-9]+)?'
+    try:
+        value = float(t.value)
+    except ValueError:
+        print('Error converting %s to real' % t.value)
+    return t
+
+# Do the binary,octal etc before decimal integer otherwise the 0 at
+# the front will match the decimal integer 0
+#
+def t_BININT(t):
+    r'0[bB][0-1]+'
+    try:
+        t.value = repr(int(t.value[2:],base=2))
+    except ValueError:
+        print('Unable to convert binary value %s' % t.value)
+    return t
+
+def t_OCTINT(t):
+    r'0[oO][0-7]+'
+    try:
+        t.value = repr(int(t.value[2:],base=8))
+    except ValueError:
+        print('Unable to convert octal value %s' % t.value)
+    return t
+
+def t_HEXINT(t):
+    r'0[xX][0-9a-fA-F]+'
+    try:
+        t.value = repr(int(t.value,base=16))
+    except ValueError:
+        print('Unable to convert hex value %s' % t.value)
+    return t
+
+def t_INTEGER(t):
+    r'[0-9]+'
+    try:
+        value = int(t.value)
+    except ValueError:
+        print('Incorrect integer value %s' % t.value)
+    return t
+
+def t_STRPREFIX(t):
+    r'r(?=["\'])|u(?=["\'])|R(?=["\'])|U(?=["\'])|ur(?=["\'])|UR(?=["\'])|Ur(?=["\'])|uR(?=["\'])'
+    return t
+
+# try longstring first as otherwise the '' will match a shortstring
+def t_LONGSTRING(t):
+    r"('''([^\\]|(\\.))*''')|(\"\"\"([^\\]|(\\.))*\"\"\")"
+    return t
+
+
+def t_SHORTSTRING(t):
+    r"('([^'\n]|(\\.))*')|(\"([^\"\n]|(\\.))*\")"
+    return t
+
+# special to avoid any ambiguity
+def t_ELSEIF(t):
+    r"(?i)ELSE\s+IF"
+    return t
+
+reserved = {
+    'and': 'AND',
+    'or': 'OR',
+    'in': 'IN',
+    'not': 'NOT',
+    'do': 'DO',
+    'Do': 'DO',
+    'for': 'FOR',
+    'For': 'FOR',
+    'loop': 'LOOP',
+    'Loop': 'LOOP',
+    'as': 'AS',
+    'with': 'WITH',
+    'With': 'WITH',
+    'where': 'WHERE',
+    'Where': 'WHERE',
+    'else': 'ELSE',
+    'Else': 'ELSE',
+    'Next': 'NEXT',
+    'next' : 'NEXT',
+    'break': 'BREAK',
+    'Break': 'BREAK',
+    'if': 'IF',
+    'If': 'IF',
+    'switch': 'SWITCH',
+    'case' : 'CASE',
+    'Function' : 'FUNCTION',
+    'function' : 'FUNCTION',
+    'Print' : 'PRINT',
+    'print' : 'PRINT',
+    'Repeat': 'REPEAT',
+    'repeat': 'REPEAT',
+    'default' : 'DEFAULT'
+    }
+
+def t_ID(t):
+    r'[a-zA-Z][a-zA-Z0-9_$]*'
+    t.type = reserved.get(t.value,'ID')
+    return t
+
+# Item tags can have underscores and digits inside, and must have
+# at least one underscore at the front
+def t_ITEM_TAG(t):
+    r'_[a-zA-Z_0-9]+'
+    return t
+
+def t_ESCAPE_NEWLINE(t):
+    r'\\\n'
+    t.lexer.lineno += 1
+
+def t_INITIAL_NEWLINE(t):
+    r'\n[\n \t]*'
+    t.lexer.lineno+=len(t.value)
+    return t
+
+def t_COMMENT(t):
+    r'\#.*'
+    pass
+
+lexer = lex.lex(reflags=re.MULTILINE)
+if __name__ == "__main__":
+    lex.runmain(lexer)

pyemaps/CifFile/drel/drel_runtime.py

@@ -0,0 +1,126 @@
+import numpy
+from numpy.linalg import eig
+
+# Python3 compatibility
+if isinstance(u"abc",str):   #Python 3
+    unicode = str
+
+def aug_append(current,extra):
+    """Add the contents of extra to current"""
+    have_list = isinstance(current,list)
+    if have_list:
+        if not isinstance(extra, list):
+            #append a single element
+            return current + [extra]
+        else:
+            newlist = current[:]
+            newlist.append(extra)
+            return newlist
+    elif isinstance(current,numpy.ndarray):
+        if current.ndim == extra.ndim + 1:
+            extra = numpy.expand_dims(extra,axis=0)
+        elif current.ndim == extra.ndim:
+            extra = numpy.expand_dims(extra,axis=0)
+            current = numpy.expand_dims(current,axis=0)
+        else:
+            raise ValueError('Arrays have mismatching sizes for concatenating: %d and %d' % (current.ndim,extra.ndim))
+        return numpy.concatenate((current,extra))
+    raise ValueError("Cannot append %s to %s" % (repr(extra),repr(current)))
+
+def aug_add(current,extra):
+    """Sum the contents of extra to current"""
+    have_list = isinstance(current,list)
+    if have_list:
+        if isinstance(extra, (float,int)):
+           # requires numpy
+           return numpy.array(current) + extra
+        elif isinstance(extra, list):
+           return numpy.array(current) + numpy.array(extra)
+    else:
+        return current + extra
+
+def aug_sub(current,extra):
+   have_list = isinstance(current,(list,numpy.ndarray))
+   if have_list:
+        if isinstance(extra, (float,int)):
+           # requires numpy
+           return numpy.array(current) - extra
+        elif isinstance(extra, (list,numpy.ndarray)):
+           return numpy.array(current) - numpy.array(extra)
+   else:
+        return current - extra
+
+def aug_remove(current,extra):
+    """Remove extra from current. Not in formal
+       specifications. Allowed to fail silently."""
+    have_list = isinstance(current,list)
+    if have_list:
+        if extra in current:
+            # not efficient as we modify in place here
+            current.remove(extra)
+            return current
+        else:
+            print('Removal Warning: %s not in %s' % (repr(extra),repr(current)))
+            return current
+    else:
+        raise ValueError("Cannot remove %s from %s" % (repr(extra),repr(current)))
+
+def drel_dot(first_arg,second_arg):
+    """Perform a multiplication on two unknown types"""
+    print("Multiply %s and %s" % (repr(first_arg),repr(second_arg)))
+    def make_numpy(input_arg):
+        if hasattr(input_arg,'__iter__'):
+            try:
+                return numpy.matrix(input_arg),True
+            except ValueError:
+                raise ValueError('Attempt to multiply non-matrix object %s' % (repr(input_arg)))
+        return input_arg,False
+    fa,first_matrix = make_numpy(first_arg)
+    sa,second_matrix = make_numpy(second_arg)
+    if first_matrix and second_matrix:  #mult of 2 non-scalars
+        if sa.shape[0] == 1:  #is a row vector
+           as_column = sa.T
+           result = (fa * as_column).T
+        else:
+           result = fa * sa
+       # detect scalars
+        if result.size == 1:
+            return result.item(0)
+       # remove extra dimension
+        elif result.ndim == 2 and 1 in result.shape:  #vector
+            return numpy.array(result).squeeze()
+        else:
+            return result
+    return fa * sa
+
+def drel_add(first_arg,second_arg):
+    """Separate string addition from the rest"""
+    if isinstance(first_arg,(unicode,str)) and isinstance(second_arg,(unicode,str)):
+        return first_arg+second_arg
+    else:
+        result = numpy.add(first_arg,second_arg)
+        return result
+
+
+def drel_eigen(in_matrix):
+    """Return 3 lists of form [a,v1,v2,v3], corresponding to the 3 eigenvalues 
+       and eigenvector components of a 3x3 matrix"""
+    vals,vects = eig(in_matrix)
+    move = list(numpy.argsort(vals))
+    move.reverse()
+    vals = vals[move]
+    vects = vects[move]
+    vects = list([[a]+list(numpy.asarray(v).ravel()) for a,v in zip(vals,vects)]) #Eigen returns 4-list
+    return vects
+
+def drel_int(in_val):
+    """Return in_val as an integer"""
+    try:
+        return in_val.astype('int')
+    except:
+        return int(in_val)
+
+def drel_strip(in_list,element):
+    """Return the nth element from the list"""
+    return [a[element] for a in in_list]
+