def round(value, decimal=0, digits=None): """ ROUND TO GIVEN NUMBER OF DIGITS, OR GIVEN NUMBER OF DECIMAL PLACES decimal - NUMBER OF DIGITS AFTER DECIMAL POINT (NEGATIVE IS VALID) digits - NUMBER OF SIGNIFICANT DIGITS (LESS THAN 1 IS INVALID) """ if value == None: return None elif value == 0: return 0 else: value = float(value) if digits != None: try: if digits <= 0: return sign(value) * pow(10, round(math_log10(abs(value)), 0)) m = pow(10, math_ceil(math_log10(abs(value)))) return _round(value / m, 0) * m except Exception as e: from mo_logs import Log Log.error("not expected", e) elif decimal <= 0: return int(_round(value, decimal)) else: return _round(value, decimal)
def sigfig(number, uncert): ''' returns number of significant figures of a quantity :param number: the value of the quantity :param uncert: the uncertainty of the quantity :return: integer giving significant figures (100 = exact number) >>> sigfig(4, 0.0) 100 >>> sigfig(12.56, 0.04) 4 >>> sigfig(5.6, 0.09999999999999999) 2 >>> sigfig(0.0, 0.14142135623730953) 0 ''' if not uncert: return 100 if not number: return 0 most = int(floor(math_log10(abs(number)))) sig = int(floor(math_log10(uncert * 1.05))) sigfig = most - sig + 1 if sigfig > 0: return sigfig return 1
def almost_equal(first, second, digits=None, places=None, delta=None): try: if first == second: return True if delta is not None: if abs(first - second) <= delta: return True else: places = coalesce(places, digits, 18) diff = math_log10(abs(first - second)) if diff < ceiling(math_log10(first)) - places: return True return False except Exception as e: from mo_logs import Log Log.error("problem comparing", cause=e)
def setDecimals(selforcls, newDecimals): if newDecimals is not None: testfor( isNumber(newDecimals) and newDecimals >= 0, DecimalsError, "Parameter decimals has to be a positive number!") else: start, end = selforcls._valueRange newDecimals = round(math_log10(math_fabs(end - start))) newDecimals = max(newDecimals, 0) newDecimals = min(newDecimals, sys.float_info.max_10_exp) selforcls._decimals = int(newDecimals)
def log10(x: float) -> float: """ Version of :func:`math.log10` that treats log(0) as ``-inf``, rather than crashing with ``ValueError: math domain error``. Args: x: parameter Returns: float: log10(x), the logarithm to base 10 of x See https://stackoverflow.com/questions/42980201/logarithm-of-zero-in-python. """ return math_log10(x) if x != 0 else MINUS_INFINITY
def word_segmentation(self, phrase, max_edit_distance=None, max_segmentation_word_length=None, ignore_token=None): """`word_segmentation` divides a string into words by inserting missing spaces at the appropriate positions misspelled words are corrected and do not affect segmentation existing spaces are allowed and considered for optimum segmentation `word_segmentation` uses a novel approach *without* recursion. https://medium.com/@wolfgarbe/fast-word-segmentation-for-noisy-text-2c2c41f9e8da While each string of length n can be segmented in 2^n−1 possible compositions https://en.wikipedia.org/wiki/Composition_(combinatorics) `word_segmentation` has a linear runtime O(n) to find the optimum composition Find suggested spellings for a multi-word input string (supports word splitting/merging). **Args**: * phrase (str): The string being spell checked. * max_segmentation_word_length (int): The maximum word length\ that should be considered. * max_edit_distance (int): The maximum edit distance between\ input and corrected words (0=no correction/segmentation\ only). * ignore_token (regex pattern): A regex pattern describing\ what words/phrases to ignore and leave unchanged **Returns**: The word segmented string, the word segmented and spelling\ corrected string, the edit distance sum between input\ string and corrected string, the sum of word occurence\ probabilities in log scale (a measure of how common and\ probable the corrected segmentation is). """ # number of all words in the corpus used to generate the # frequency dictionary. This is used to calculate the word # occurrence probability p from word counts c : p=c/N. N equals # the sum of all counts c in the dictionary only if the # dictionary is complete, but not if the dictionary is # truncated or filtered N = 1024908267229 if max_edit_distance is None: max_edit_distance = self._max_dictionary_edit_distance if max_segmentation_word_length is None: max_segmentation_word_length = self._max_length array_size = min(max_segmentation_word_length, len(phrase)) compositions = [Composition()] * array_size circular_index = cycle(range(array_size)) idx = -1 # outer loop (column): all possible part start positions for j in range(len(phrase)): # inner loop (row): all possible part lengths (from start # position): part can't be bigger than longest word in # dictionary (other than long unknown word) imax = min(len(phrase) - j, max_segmentation_word_length) for i in range(1, imax + 1): # get top spelling correction/ed for part part = phrase[j:j + i] separator_len = 0 top_ed = 0 top_log_prob = 0.0 top_result = "" if part[0].isspace(): # remove space for levensthein calculation part = part[1:] else: # add ed+1: space did not exist, had to be inserted separator_len = 1 # remove space from part1, add number of removed spaces # to top_ed top_ed += len(part) # remove space. # add number of removed spaces to ed part = part.replace(" ", "") top_ed -= len(part) results = self.lookup(part, Verbosity.TOP, max_edit_distance, ignore_token=ignore_token) if results: top_result = results[0].term top_ed += results[0].distance # Naive Bayes Rule. We assume the word # probabilities of two words to be independent. # Therefore the resulting probability of the word # combination is the product of the two word # probabilities. Instead of computing the product # of probabilities we are computing the sum of the # logarithm of probabilities because the # probabilities of words are about 10^-10, the # product of many such small numbers could exceed # (underflow) the floating number range and become # zero. log(ab)=log(a)+log(b) top_log_prob = math_log10( float(results[0].count) / float(N)) else: top_result = part # default, if word not found. otherwise long input # text would win as long unknown word (with # ed=edmax+1), although there there should many # spaces inserted top_ed += len(part) top_log_prob = math_log10(10.0 / N / math_pow(10.0, len(part))) dest = (i + idx) % array_size # set values in first loop if j == 0: compositions[dest] = Composition(part, top_result, top_ed, top_log_prob) # pylint: disable=C0301,R0916 elif (i == max_segmentation_word_length # replace values if better log_prob_sum, if same # edit distance OR one space difference or ((compositions[idx].distance_sum + top_ed == compositions[dest].distance_sum or compositions[idx].distance_sum + separator_len + top_ed == compositions[dest].distance_sum) and compositions[dest].log_prob_sum < compositions[idx].log_prob_sum + top_log_prob) # replace values if smaller edit distance or compositions[idx].distance_sum + separator_len + top_ed < compositions[dest].distance_sum): compositions[dest] = Composition( compositions[idx].segmented_string + " " + part, compositions[idx].corrected_string + " " + top_result, compositions[idx].distance_sum + separator_len + top_ed, compositions[idx].log_prob_sum + top_log_prob) idx = next(circular_index) return compositions[idx]
def qlog(a): return Q(math_log10(a.number), "log(%s)", a.units, abs(a.uncert / a.number), a.prefu, (a,))
def mostsig(number, ope=1.00000000001): return int(floor(math_log10(abs(number) * ope))) def latex_number(ascii):
def unit_string(value, units, prefu={'M', 'L', 'J', 'C', 'V', 'N', 'W', 'Pa'}): """Determine the most compact set of units for a quantity given in SI units. Also, choose which units of equal dimensions to choose while keeping the number near 1. Returns: (the number(float) and, as two lists, the positive and negative units of the quantity >>> unit_string(8.314, (0, 1, 2, -2, -1, -1, 0, 0), {'K', 'J', 'mol'}) (8.314, [('J', 1)], [('K', 1), ('mol', 1)]) >>> unit_string(8.314, (0, 1, 2, -2, -1, -1, 0, 0), set()) (8.314, [('kg', 1), ('m', 2)], [('K', 1), ('s', 2), ('mol', 1)]) >>> unit_string(0.00513, (0, 0, 1, 0, 0, 0, 0, 0), {'mm'}) (5.13, [('mm', 1)], []) >>> unit_string(0.04713, (0, 0, 1, 0, 0, 0, 0, 0), {'m', 'mm'}) (47.13, [('mm', 1)], []) >>> unit_string(4.713, (0, 0, 1, 0, 0, 0, 0, 0), {'m', 'mm'}) (4.713, [('m', 1)], []) """ if units == unity or not value: if value and '%' in prefu: return value*100, [('%', 1)], [] return value, "", "" SIunits = list(units) derived = dict((pu, 0) for pu in prefu if (pu in unitquant and sum(abs(t) for t in unitquant[pu].units) > 1)) while derived: (improvement, d, sign) = try_all_derived(SIunits, derived) if improvement <= 0: break derived[d] += sign for i, used_in_derived in enumerate(unitquant[d].units): SIunits[i] -= used_in_derived * sign value /= unitquant[d].number ** sign allunits = dict([(x, derived[x]) for x in derived if derived[x]]) DUS = [du for du in allunits if du in derived] for DU in DUS: # choose between atm and mmHg etc. choices = [pu for pu in derived if unitquant[pu].units == unitquant[DU].units] if not choices: break quality = [(abs(math_log10(abs(value) / (unitquant[c].number / unitquant[DU].number) ** allunits[DU]) - 1.0), c) for c in choices] best = min(quality)[1] if best != DU: allunits[best] = allunits[DU] value /= (unitquant[best].number / unitquant[DU].number) ** allunits[best] allunits[DU] = 0 for i, SIU in enumerate(SIunit_symbols): # choose between m, cm, mm etc. if not SIunits[i]: continue choices = [pu for pu in prefu if (pu not in derived and pu in unitquant) and unitquant[pu].units[i]] if not choices: break quality = [(abs(math_log10(abs(value) / unitquant[c].number ** (SIunits[i] / unitquant[c].units[i])) - 1.0), c) for c in choices] best = min(quality)[1] allunits[best] = Fraction(SIunits[i], unitquant[best].units[i]) if allunits[best].denominator == 1: allunits[best] = int(allunits[best]) SIunits[i] = 0 value /= unitquant[best].number ** allunits[best] for u, d in zip(SIunit_symbols, SIunits): if d: allunits[u] = d #print('unitstring', allunits, prefu) if '°ΔC' in prefu and 'K' in allunits: allunits['°ΔC'] = allunits['K'] allunits['K'] = 0 #rint('unitstring delC', allunits) elif '°aC' in prefu and allunits == {'K':1}: #unitstring {'K': 1} {'°aC', 'K'} allunits = {'°aC':1} value -= 273.15 #rint('unitstring absC', allunits) poslist = [(u, exp) for u, exp in allunits.items() if exp > 0] neglist = [(u, -exp) for u, exp in allunits.items() if exp < 0] return value, poslist, neglist
def unit_string(value, units, prefu={'M', 'L', 'J', 'C', 'V', 'N', 'W', 'Pa'}): """Determine the most compact set of units for a quantity given in SI units. Also, choose which units of equal dimensions to choose while keeping the number near 1. Returns: (the number(float) and, as two lists, the positive and negative units of the quantity >>> unit_string(8.314, (0, 1, 2, -2, -1, -1, 0, 0), {'K', 'J', 'mol'}) (8.314, [('J', 1)], [('K', 1), ('mol', 1)]) >>> unit_string(8.314, (0, 1, 2, -2, -1, -1, 0, 0), set()) (8.314, [('kg', 1), ('m', 2)], [('K', 1), ('s', 2), ('mol', 1)]) >>> unit_string(0.00513, (0, 0, 1, 0, 0, 0, 0, 0), {'mm'}) (5.13, [('mm', 1)], []) >>> unit_string(0.04713, (0, 0, 1, 0, 0, 0, 0, 0), {'m', 'mm'}) (47.13, [('mm', 1)], []) >>> unit_string(4.713, (0, 0, 1, 0, 0, 0, 0, 0), {'m', 'mm'}) (4.713, [('m', 1)], []) """ if units == unity or not value: return value, "", "" SIunits = list(units) derived = dict((pu, 0) for pu in prefu if sum(abs(t) for t in unitquant[pu].units) > 1) while derived: (improvement, d, sign) = try_all_derived(SIunits, derived) if improvement <= 0: break derived[d] += sign for i, used_in_derived in enumerate(unitquant[d].units): SIunits[i] -= used_in_derived * sign value /= unitquant[d].number ** sign allunits = dict([(x, derived[x]) for x in derived if derived[x]]) DUS = [du for du in allunits if du in derived] for DU in DUS: # choose between atm and mmHg etc. choices = [pu for pu in derived if unitquant[pu].units == unitquant[DU].units] if not choices: break quality = [(abs(math_log10(abs(value) / (unitquant[c].number / unitquant[DU].number) ** allunits[DU]) - 1.0), c) for c in choices] best = min(quality)[1] if best != DU: allunits[best] = allunits[DU] value /= (unitquant[best].number / unitquant[DU].number) ** allunits[best] allunits[DU] = 0 for i, SIU in enumerate(SIunit_symbols): # choose between m, cm, mm etc. if not SIunits[i]: continue choices = [pu for pu in prefu if (pu not in derived) and unitquant[pu].units[i]] if not choices: break quality = [(abs(math_log10(abs(value) / unitquant[c].number ** (SIunits[i] / unitquant[c].units[i])) - 1.0), c) for c in choices] best = min(quality)[1] allunits[best] = Fraction(SIunits[i], unitquant[best].units[i]) if allunits[best].denominator == 1: allunits[best] = int(allunits[best]) SIunits[i] = 0 value /= unitquant[best].number ** allunits[best] for u, d in zip(SIunit_symbols, SIunits): if d: allunits[u] = d poslist = [(u, exp) for u, exp in allunits.items() if exp > 0] neglist = [(u, -exp) for u, exp in allunits.items() if exp < 0] return value, poslist, neglist
def r6_dnn_image_display(target_dirname, dnn_image_obj=None, show_fig=False): LOGGER.info('{}: r6: Turning upsampled envelope into image...'.format(target_dirname)) if dnn_image_obj is None: dnn_image_obj = loadmat(os_path_join(target_dirname, DNN_IMAGE_FNAME)) beam_position_x_up = dnn_image_obj['beam_position_x_up'] depth = dnn_image_obj['depth'] envUp_dB = dnn_image_obj['envUp_dB'] env_up = dnn_image_obj['envUp'] LOGGER.debug('{}: r6: Finished loading vars'.format(target_dirname)) x = np_squeeze(beam_position_x_up) # beam_position_x_up y = np_squeeze(depth) # depth LOGGER.debug('{}: r6: Finished squeezing x, y'.format(target_dirname)) fig, ax = plt_subplots() LOGGER.debug('{}: r6: Finished plt.figure'.format(target_dirname)) image = ax.imshow(envUp_dB, vmin=-60, vmax=0, cmap='gray', aspect='auto', extent=[x[0]*1000, x[-1]*1000, y[-1]*1000, y[0]*1000]) ax.set_aspect('equal') LOGGER.debug('{}: r6: Finished plt.imshow'.format(target_dirname)) fig.colorbar(image) LOGGER.debug('{}: r6: Finished plt.colorbar'.format(target_dirname)) # plt_xlabel('lateral (mm)', fontsize=FONT_SIZE) ax.set_xlabel('lateral (mm)', fontsize=FONT_SIZE) # plt_ylabel('axial (mm)', fontsize=FONT_SIZE) ax.set_ylabel('axial (mm)', fontsize=FONT_SIZE) LOGGER.debug('{}: r6: Finished plt.xlabel/ylabel'.format(target_dirname)) # if show_fig is True: # plt_show(block=False) # Save image to file dnn_image_path = os_path_join(target_dirname, DNN_IMAGE_SAVE_FNAME) fig.savefig(dnn_image_path) plt_close(fig) LOGGER.debug('{}: r6: Finished saving figure'.format(target_dirname)) # scan_battery_dirname = os_path_dirname(target_dirname) # process_scripts_dirpath = os_path_join(scan_battery_dirname, PROCESS_SCRIPTS_DIRNAME) # circle_radius = load_single_value(process_scripts_dirpath, CIRCLE_RADIUS_FNAME) # circle_coords_x = load_single_value(process_scripts_dirpath, CIRCLE_COORDS_X_FNAME) # circle_coords_y = load_single_value(process_scripts_dirpath, CIRCLE_COORDS_Y_FNAME) # xx, yy = np_meshgrid(x, y) # mask_in = get_circular_mask(xx, yy, (circle_coords_x, circle_coords_y), circle_radius) # # # mask_in # # create rectangular region outside lesion # box_xmin_right = load_single_value(process_scripts_dirpath, BOX_XMIN_RIGHT_FNAME) # box_xmax_right = load_single_value(process_scripts_dirpath, BOX_XMAX_RIGHT_FNAME) # # box_xmin_left = load_single_value(process_scripts_dirpath, BOX_XMIN_LEFT_FNAME) # box_xmax_left = load_single_value(process_scripts_dirpath, BOX_XMAX_LEFT_FNAME) # # # Box shares y position and height with circle (diameter) # ymin = circle_coords_y - circle_radius # ymax = circle_coords_y + circle_radius # mask_out_left = (xx >= box_xmin_left) * (xx <= box_xmax_left) * (yy >= ymin) * (yy <= ymax) # mask_out_right = get_rectangle_mask(xx, yy, box_xmin_right, box_xmax_right, ymin, ymax) # mask_out = mask_out_left | mask_out_right # Display circle and boxes # with_circle = envUp_dB.copy() # # # with_circle[mask_out_left+mask_in+mask_out_right] = 0 # # plt.figure(figsize=(12,16)) # plt.imshow(with_circle, vmin=-60, vmax=0, cmap='gray', aspect='auto', extent = [beam_position_x_up[0]*1000,beam_position_x_up[-1]*1000,depth[-1]*1000, depth[0]*1000]) # plt.colorbar() # FONT_SIZE = 20 # plt.xlabel('lateral (mm)', fontsize=FONT_SIZE) # plt.ylabel('axial (mm)', fontsize=FONT_SIZE) # plt.show() # Calculate image statistics # print('r6: env_up.shape =', env_up.shape) mask_in, mask_out = get_masks(target_dirname) LOGGER.debug('{}: r6: Finished loading masks'.format(target_dirname)) # print('r6: mask_in.shape={}, mask_out.shape={}'.format(mask_in.shape, mask_out.shape)) env_up_inside_lesion = env_up[mask_in] mean_in = env_up_inside_lesion.mean() var_in = env_up_inside_lesion.var(ddof=1) # ddof is important cuz Matlab env_up_outside_lesion = env_up[mask_out] mean_out = env_up_outside_lesion.mean() var_out = env_up_outside_lesion.var(ddof=1) # ddof is important cuz Matlab LOGGER.debug('{}: r6: Finished mean and var calculations'.format(target_dirname)) CR = -20 * math_log10(mean_in / mean_out) CNR = 20 * math_log10(abs(mean_in - mean_out)/math_sqrt(var_in + var_out)) SNR = mean_out / math_sqrt(var_out) LOGGER.debug('{}: r6: Finished speckle stats calculations'.format(target_dirname)) # Save image statistics to file speckle_stats = [CR, CNR, SNR, mean_in, mean_out, var_in, var_out] speckle_stats_path = os_path_join(target_dirname, SPECKLE_STATS_FNAME) with open(speckle_stats_path, 'w') as f: f.write("\n".join([str(item) for item in speckle_stats])) LOGGER.debug('{}: r6: Finished saving .txt'.format(target_dirname)) # Also save image statistics json as a redundant (but more readable) method speckle_stats_dict = { 'CR': CR, 'CNR': CNR, 'SNR': SNR, 'mean_inside_lesion': mean_in, 'variance_inside_lesion': var_in, 'mean_outside_lesion': mean_out, 'variance_outside_lesion': var_out, } speckle_stats_dict_path = os_path_join(target_dirname, SPECKLE_STATS_DICT_FNAME) with open(speckle_stats_dict_path, 'w') as f: json_dump(speckle_stats_dict, f, indent=4) LOGGER.debug('{}: r6: Finished saving .json'.format(target_dirname)) LOGGER.info('{}: r6 Done'.format(target_dirname))