| 1 | ''' |
|---|
| 2 | *GSASIIpy3: Python 3.x Routines* |
|---|
| 3 | ================================ |
|---|
| 4 | |
|---|
| 5 | Module to hold python 3-compatible code, to keep it separate from |
|---|
| 6 | code that will break with __future__ options. |
|---|
| 7 | |
|---|
| 8 | ''' |
|---|
| 9 | from __future__ import division |
|---|
| 10 | import numpy as np |
|---|
| 11 | import GSASIIpath |
|---|
| 12 | GSASIIpath.SetVersionNumber("$Revision: 2060 $") |
|---|
| 13 | # declare symbol (pi) and functions allowed in expressions |
|---|
| 14 | sind = sin = s = lambda x: np.sin(x*np.pi/180.) |
|---|
| 15 | cosd = cos = c = lambda x: np.cos(x*np.pi/180.) |
|---|
| 16 | tand = tan = t = lambda x: np.tan(x*np.pi/180.) |
|---|
| 17 | sqrt = sq = lambda x: np.sqrt(x) |
|---|
| 18 | pi = np.pi |
|---|
| 19 | |
|---|
| 20 | def FormulaEval(string): |
|---|
| 21 | '''Evaluates a algebraic formula into a float, if possible. Works |
|---|
| 22 | properly on fractions e.g. 2/3 only with python 3.0+ division. |
|---|
| 23 | |
|---|
| 24 | Expressions such as 2/3, 3*pi, sin(45)/2, 2*sqrt(2), 2**10 can all |
|---|
| 25 | be evaluated. |
|---|
| 26 | |
|---|
| 27 | :param str string: Character string containing a Python expression |
|---|
| 28 | to be evaluated. |
|---|
| 29 | |
|---|
| 30 | :returns: the value for the expression as a float or None if the expression does not |
|---|
| 31 | evaluate to a valid number. |
|---|
| 32 | |
|---|
| 33 | ''' |
|---|
| 34 | try: |
|---|
| 35 | val = float(eval(string)) |
|---|
| 36 | if np.isnan(val) or np.isinf(val): return None |
|---|
| 37 | except: |
|---|
| 38 | return None |
|---|
| 39 | return val |
|---|
| 40 | |
|---|
| 41 | def FormatPadValue(val,maxdigits=None): |
|---|
| 42 | '''Format a float to fit in ``maxdigits[0]`` spaces with maxdigits[1] after decimal. |
|---|
| 43 | |
|---|
| 44 | :param float val: number to be formatted. |
|---|
| 45 | |
|---|
| 46 | :param list maxdigits: the number of digits & places after decimal to be used for display of the |
|---|
| 47 | number (defaults to [10,2]). |
|---|
| 48 | |
|---|
| 49 | :returns: a string with exactly maxdigits[0] characters (except under error conditions), |
|---|
| 50 | but last character will always be a space |
|---|
| 51 | ''' |
|---|
| 52 | if maxdigits is None: |
|---|
| 53 | digits = [10,2] |
|---|
| 54 | else: |
|---|
| 55 | digits = list(maxdigits) |
|---|
| 56 | fmt = '{:'+str(digits[0])+'}' |
|---|
| 57 | s = fmt.format(FormatValue(val,digits)) |
|---|
| 58 | if s[-1] == ' ': |
|---|
| 59 | return s |
|---|
| 60 | else: |
|---|
| 61 | return s+' ' |
|---|
| 62 | |
|---|
| 63 | |
|---|
| 64 | def FormatValue(val,maxdigits=None): |
|---|
| 65 | '''Format a float to fit in at most ``maxdigits[0]`` spaces with maxdigits[1] after decimal. |
|---|
| 66 | Note that this code has been hacked from FormatSigFigs and may have unused sections. |
|---|
| 67 | |
|---|
| 68 | :param float val: number to be formatted. |
|---|
| 69 | |
|---|
| 70 | :param list maxdigits: the number of digits & places after decimal to be used for display of the |
|---|
| 71 | number (defaults to [10,2]). |
|---|
| 72 | |
|---|
| 73 | :returns: a string with <= maxdigits characters (usually). |
|---|
| 74 | ''' |
|---|
| 75 | if 'str' in str(type(val)) and (val == '?' or val == '.'): |
|---|
| 76 | return val |
|---|
| 77 | if maxdigits is None: |
|---|
| 78 | digits = [10,2] |
|---|
| 79 | else: |
|---|
| 80 | digits = list(maxdigits) |
|---|
| 81 | fmt="{:."+str(digits[1])+"f}" |
|---|
| 82 | string = fmt.format(float(val)).strip() # will standard .f formatting work? |
|---|
| 83 | if len(string) <= digits[0]: |
|---|
| 84 | if ':' in string: # deal with weird bug where a colon pops up in a number when formatting (EPD 7.3.2!) |
|---|
| 85 | string = str(val) |
|---|
| 86 | if digits[1] > 0: # strip off extra zeros on right side |
|---|
| 87 | string = string.rstrip('0') |
|---|
| 88 | if string[-1] == '.': string += "0" |
|---|
| 89 | return string |
|---|
| 90 | if val < 0: digits[0] -= 1 # negative numbers, reserve space for the sign |
|---|
| 91 | decimals = digits[0] - digits[1] |
|---|
| 92 | if abs(val) > 1e99: # for very large numbers, use scientific notation and use all digits |
|---|
| 93 | fmt = "{" + (":{:d}.{:d}g".format(digits[0],digits[0]-6))+"}" |
|---|
| 94 | elif abs(val) > 1e9: |
|---|
| 95 | fmt = "{" + (":{:d}.{:d}g".format(digits[0],digits[0]-5))+"}" |
|---|
| 96 | elif abs(val) < 10**(4-decimals): # make sure at least 4 decimals show |
|---|
| 97 | # this clause is probably no longer needed since the number probably shows as 0.0 |
|---|
| 98 | decimals = min(digits[0]-5,digits[1]) |
|---|
| 99 | fmt = "{" + (":{:d}.{:d}g".format(digits[0],decimals))+"}" |
|---|
| 100 | elif abs(val) >= 10**(decimals-1): # deal with large numbers in smaller spaces |
|---|
| 101 | decimals = max(0,digits[0]-5) |
|---|
| 102 | fmt = "{" + (":{:d}.{:d}g".format(digits[0],decimals))+"}" |
|---|
| 103 | elif abs(val) < 1: # use f format for small numbers |
|---|
| 104 | # this clause is probably no longer needed since the number probably shows as 0.0 |
|---|
| 105 | decimals = min(digits[0]-3,digits[1]) |
|---|
| 106 | fmt = "{" + (":{:d}.{:d}f".format(digits[0],decimals))+"}" |
|---|
| 107 | else: # in range where g formatting should do what I want |
|---|
| 108 | # used? |
|---|
| 109 | decimals = digits[0] - 1 |
|---|
| 110 | fmt = "{" + (":{:d}.{:d}g".format(digits[0],decimals))+"}" |
|---|
| 111 | try: |
|---|
| 112 | return fmt.format(float(val)).strip() |
|---|
| 113 | except ValueError as err: |
|---|
| 114 | print 'FormatValue Error with val,maxdigits,fmt=',val,maxdigits,fmt |
|---|
| 115 | return str(val) |
|---|
| 116 | |
|---|
| 117 | def FormatSigFigs(val, maxdigits=10, sigfigs=5, treatAsZero=1e-20): |
|---|
| 118 | '''Format a float to use ``maxdigits`` or fewer digits with ``sigfigs`` |
|---|
| 119 | significant digits showing (if room allows). |
|---|
| 120 | |
|---|
| 121 | :param float val: number to be formatted. |
|---|
| 122 | |
|---|
| 123 | :param int maxdigits: the number of digits to be used for display of the |
|---|
| 124 | number (defaults to 10). |
|---|
| 125 | |
|---|
| 126 | :param int sigfigs: the number of significant figures to use, if room allows |
|---|
| 127 | |
|---|
| 128 | :param float treatAsZero: numbers that are less than this in magnitude |
|---|
| 129 | are treated as zero. Defaults to 1.0e-20, but this can be disabled |
|---|
| 130 | if set to None. |
|---|
| 131 | |
|---|
| 132 | :returns: a string with <= maxdigits characters (I hope). |
|---|
| 133 | ''' |
|---|
| 134 | if 'str' in str(type(val)) and (val == '?' or val == '.'): |
|---|
| 135 | return val |
|---|
| 136 | if treatAsZero is not None: |
|---|
| 137 | if abs(val) < treatAsZero: |
|---|
| 138 | return '0.0' |
|---|
| 139 | # negative numbers, leave room for a sign |
|---|
| 140 | if val < 0: maxdigits -= 1 |
|---|
| 141 | if abs(val) < 1e-99 or abs(val) > 9.999e99: |
|---|
| 142 | decimals = min(maxdigits-6,sigfigs) |
|---|
| 143 | fmt = "{" + (":{:d}.{:d}g".format(maxdigits,decimals))+"}" # create format string |
|---|
| 144 | elif abs(val) < 1e-9 or abs(val) > 9.999e9: |
|---|
| 145 | decimals = min(maxdigits-5,sigfigs) |
|---|
| 146 | fmt = "{" + (":{:d}.{:d}g".format(maxdigits,decimals))+"}" |
|---|
| 147 | elif abs(val) < 9.9999999*10**(sigfigs-maxdigits): |
|---|
| 148 | decimals = min(maxdigits-5,sigfigs) |
|---|
| 149 | fmt = "{" + (":{:d}.{:d}g".format(maxdigits,decimals))+"}" |
|---|
| 150 | elif abs(val) >= 10**sigfigs: # deal with large numbers in smaller spaces |
|---|
| 151 | decimals = min(maxdigits-5,sigfigs) |
|---|
| 152 | fmt = "{" + (":{:d}.{:d}g".format(maxdigits,decimals))+"}" |
|---|
| 153 | elif abs(val) < 1: # small numbers, add to decimal places |
|---|
| 154 | decimals = sigfigs - int(np.log10(abs(val))) |
|---|
| 155 | fmt = "{" + (":{:d}.{:d}f".format(maxdigits,decimals))+"}" |
|---|
| 156 | else: # larger numbers, remove decimal places |
|---|
| 157 | decimals = sigfigs - 1 - int(np.log10(abs(val))) |
|---|
| 158 | print decimals,maxdigits,val |
|---|
| 159 | if decimals <= 0: |
|---|
| 160 | fmt = "{" + (":{:d}.0f".format(maxdigits))+"}." |
|---|
| 161 | else: |
|---|
| 162 | fmt = "{" + (":{:d}.{:d}f".format(maxdigits,decimals))+"}" |
|---|
| 163 | try: |
|---|
| 164 | return fmt.format(float(val)).strip() |
|---|
| 165 | except ValueError as err: |
|---|
| 166 | print 'FormatValue Error with val,maxdigits, sigfigs, fmt=',val, maxdigits,sigfigs, fmt |
|---|
| 167 | return str(val) |
|---|
| 168 | |
|---|
| 169 | if __name__ == '__main__': |
|---|
| 170 | for i in (1.23456789e-129,1.23456789e129,1.23456789e-99,1.23456789e99,-1.23456789e-99,-1.23456789e99): |
|---|
| 171 | print FormatSigFigs(i),i |
|---|
| 172 | for i in (1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000): |
|---|
| 173 | print FormatSigFigs(1.23456789e-9*i),1.23456789e-9*i |
|---|
| 174 | for i in (1,10,100,1000,10000,100000,1000000,10000000,100000000): |
|---|
| 175 | print FormatSigFigs(1.23456789e9/i),1.23456789e9/i |
|---|
| 176 | |
|---|
| 177 | print FormatSigFigs(200,10,3) |
|---|
