def test_igammacinv_inverse_large_a(self, dtype, rtol): seed_stream = test_util.test_seed_stream() a = tf.random.uniform( [int(1e4)], 100., 10000., dtype=dtype, seed=seed_stream()) p = tf.random.uniform([int(1e4)], 0., 1., dtype=dtype, seed=seed_stream()) igammacinv, a, p = self.evaluate([tfp.math.igammacinv(a, p), a, p]) self.assertAllClose(scipy_special.gammainccinv(a, p), igammacinv, rtol=rtol)
def percentile(self, p): lambda_ = self.lambda_ sigma_ = exp(self.ln_sigma_) if lambda_ > 0: return exp(sigma_ * log(gammainccinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_) return exp(sigma_ * log(gammaincinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_)
def gs_val_meso(gs, t, ca, k1_interp, k2_interp, cp_interp, psi_lcrit_interp, psi_x, VPDinterp, psi_63, w_exp, Kmax, psi_sat, gamma, b, d_r, z_r, RAI, lai, lam): psi_crit = psi_lcrit_interp(psi_x) VPD = VPDinterp(t) k1 = k1_interp(t) k2 = k2_interp(t) cp = cp_interp(t) x = (psi_x / psi_sat)**-(1 / b) psi_r = 1.6 * gs * VPD / gSR_val(x, gamma, b, d_r, z_r, RAI, lai) + psi_x # res = root(lambda psi_l: 1.6 * gs * VPD - Kmax * (psi_63 / w_exp) * # (gammaincc(1 / w_exp, (psi_r / psi_63) ** w_exp) - gammaincc(1 / w_exp, (psi_l / psi_63) ** w_exp)), # psi_r + 0.1, method='hybr') # psi_l = res.get('x') psi_l_temp = gammainccinv( 1 / w_exp, -1.6 * gs * VPD * w_exp / (gammafunc(1 / w_exp) * Kmax * psi_63) + gammaincc(1 / w_exp, (psi_r / psi_63)**w_exp)) psi_l = psi_63 * psi_l_temp**(1 / w_exp) phi = 1 - psi_l / psi_crit part1 = dAdgs(t, gs, ca, k1_interp, k2_interp, cp_interp, phi) part2 = dAdB(t, gs, ca, k1_interp, k2_interp, cp_interp, phi) *\ dB_dgs(cp, k2, psi_l, psi_crit, psi_x, psi_r, VPD, psi_63, w_exp, Kmax, psi_sat, gamma, b, d_r, z_r, RAI, lai) B = (cp + k2) / phi return part1 + part2 - 1.6 * lam * VPD * np.sqrt( (B + ca - cp)**2 * gs**2 + 2 * (B - ca + cp) * gs * k1 + k1**2)
def simulate_aftershock_time(log10_c, omega, log10_tau, size=1): # time delay in days c = np.power(10, log10_c) tau = np.power(10, log10_tau) y = np.random.uniform(size=size) return gammainccinv(-omega, (1 - y) * gammaincc(-omega, c / tau)) * tau - c
def cdfcinv(self, pvalc): """ return the inverse of cdfc = 1-cdf useful for limits with very low probablity pvalc : float 1-pval: zero corresponds to infinite flux """ e,beta,mu = self.altpars() if e==0: return np.nan gcbar = lambda x : special.gammaincc(mu+1, beta+x) #cchat = lambda x : gcbar(x)/gcbar(0) cchatinv = lambda pv : special.gammainccinv( mu+1, pv*gcbar(0) )-beta return cchatinv(pvalc)/e
def percentile(self, p): lambda_ = self.lambda_ # sigma_ = exp(self.ln_sigma_) # 削除 if lambda_ > 0: # 変更前↓ # return exp(sigma_ * log(gammainccinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_) # 変更後↓ return exp(lambda_ * log(gammainccinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_) # 変更前↓ # return exp(sigma_ * log(gammaincinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_) # 変更後↓ return exp(lambda_ * log(gammaincinv(1 / lambda_ ** 2, p) * lambda_ ** 2) / lambda_) * exp(self.mu_)
def test_igamci(self): a_list = np.arange(0.01, 10, 0.05) q_list = np.arange(0, 10, 0.1) test_params = cartesian([a_list, q_list]).astype(np.float64) python_results = np.zeros(test_params.shape[0]) for ind in range(test_params.shape[0]): python_results[ind] = gammainccinv(test_params[ind, 0], test_params[ind, 1]) opencl_results = igamci().evaluate( { 'a': test_params[:, 0], 'q': test_params[:, 1] }, test_params.shape[0]) assert_allclose(opencl_results, python_results, atol=1e-7, rtol=1e-7)
def get_ivic_snr_thr(npulses, pfa_thr=1e-3): """ Get the threshold for steps 3 and 6 of ivic Parameters ---------- npulses : 1D array array with the number of pulses in a ray pfa_thr : float the desired probability of false alarm Returns ------- snr_thr : 1D array The snr threshold corresponding to each number of pulses according to the desired probability of false alarm """ return gammainccinv(npulses, pfa_thr) / npulses
def gs_val_profit(gs, t, ca, k1_interp, k2_interp, cp_interp, trans_max_interp, k_max_interp, k_crit_interp, psi_x, VPDinterp, psi_63, w_exp, Kmax, psi_sat, gamma, b, d_r, z_r, RAI, lai): trans_max = trans_max_interp(psi_x) k_max = k_max_interp(psi_x) k_crit = k_crit_interp(psi_x) VPD = VPDinterp(t) k1 = k1_interp(t) k2 = k2_interp(t) cp = cp_interp(t) a = 1.6 x = (psi_x / psi_sat)**-(1 / b) psi_r = a * gs * VPD / gSR_val(x, gamma, b, d_r, z_r, RAI, lai) + psi_x psi_l_temp = gammainccinv( 1 / w_exp, -1.6 * gs * VPD * w_exp / (gammafunc(1 / w_exp) * Kmax * psi_63) + gammaincc(1 / w_exp, (psi_r / psi_63)**w_exp)) psi_l = psi_63 * psi_l_temp**(1 / w_exp) grl_psil = grl_val(psi_l, psi_63, w_exp, Kmax) grl_psir = grl_val(psi_r, psi_63, w_exp, Kmax) gSR = gSR_val(x, gamma, b, d_r, z_r, RAI, lai) dEdpsil = grl_psil * gSR / (grl_psir + gSR) gs_max = trans_max / a / VPD Amax = A_here(gs_max, ca, k1, k2, cp) d2Edpsil2 = dEdpsil * (-(w_exp / psi_63) * (psi_l / psi_63)**(w_exp - 1) + grl_psir * (w_exp / psi_63) * (psi_r / psi_63)**(w_exp - 1) * grl_psil / (grl_psir + gSR)**2) part1 = dAdgs(t, gs, ca, k1_interp, k2_interp, cp_interp, 1) * dEdpsil / (a * VPD) part2 = - Amax * d2Edpsil2 / (k_max - k_crit) *\ np.sqrt((k2 + ca) ** 2 * gs ** 2 + 2 * (k2 - ca + 2 * cp) * gs * k1 + k1 ** 2) return part2 - part1
def _ppf(self, q, a): return 1.0 / special.gammainccinv(a, q)
def _upper(self, a): return 1.0 / special.gammainccinv(a, 1 - 1e-16)
def quantile(self, p): # TODO: Check if you need to subtract 1 from the result # TODO: Check if args are in the right order return gammainccinv(p, self.lamb)
def get_ivic_flat_reg_var_max(npulses, flat_reg_wlen, n=40., prob_thr=0.01): """ Get the threshold for maximum local variance of noise [dB] Parameters ---------- npulses : 1D array array with the number of pulses in a ray flat_reg_wlen : int the length of the flat region window in bins n : float the mean noise power prob_thr : float Probably of falsely detecting noise-only flat section as contaminated with signal Returns ------- var_thr : 1D array The thresholds corresponding to each number of pulses """ y = np.arange(0.0001, 1e4, 0.01) log_e = np.log10(np.e) log_log = np.log10(np.log(10.)) wconst1 = flat_reg_wlen - 1 wconst2 = flat_reg_wlen - 2 + 1 / flat_reg_wlen wconst3 = flat_reg_wlen * flat_reg_wlen - 3 * flat_reg_wlen + 5 - 3 / flat_reg_wlen wconst4 = ((-2 * flat_reg_wlen * flat_reg_wlen * flat_reg_wlen + 12 * flat_reg_wlen * flat_reg_wlen - 22 * flat_reg_wlen + 12) / flat_reg_wlen) wconst5 = 4 * (2 - flat_reg_wlen - 1 / flat_reg_wlen) wconst6 = ((flat_reg_wlen - 1) * (flat_reg_wlen - 2) * (flat_reg_wlen - 3) / flat_reg_wlen) var_thr = np.ma.masked_all(len(npulses)) for i, npuls in enumerate(npulses): pdb_part1 = np.power( 10., np.log10(npuls / n) * npuls + log_log - gammaln(npuls) * log_e) pdb = np.empty(4) for j in range(pdb.size): k = j + 1 # find first 0 crossing f_y = _func_flat_reg(y, k, npuls, n) ind = np.where(f_y != 0.)[0] cons_list = np.split(ind, np.where(np.diff(ind) != 1)[0] + 1) ind = cons_list[0][-1] # solve integral pdb[j] = pdb_part1 * integrate.quad( _func_flat_reg, 0., y[ind], args=(k, npuls, n))[0] pdb_1_2 = pdb[0] * pdb[0] vardb_1 = wconst1 * (pdb[1] - pdb_1_2) vardb_2 = (pdb[3] * wconst2 + pdb[1] * pdb[1] * wconst3 + pdb[1] * pdb_1_2 * wconst4 + pdb[0] * pdb[2] * wconst5 + wconst6 * pdb_1_2 * pdb_1_2) vardb_1_2 = vardb_1 * vardb_1 alpha = vardb_1_2 / (vardb_2 - vardb_1_2) theta = (vardb_2 - vardb_1_2) / vardb_1 var_thr[i] = gammainccinv(alpha, prob_thr) * theta return var_thr
def _inv_nchi_cdf(N, K, alpha): """Inverse CDF for the noncentral chi distribution See [1]_ p.3 section 2.3""" return gammainccinv(N * K, 1 - alpha) / K
def _ppf(self, q, a): fac = special.gammainccinv(a,1-abs(2*q-1)) return np.where(q>0.5, fac, -fac)
def _upper(self, a): return special.gammainccinv(a, 2e-15)
def _munp(self, n, zm, a, b): k = (a+1)/b z0 = zm/sc.gammainccinv(k, 0.5)**(1/b) return z0**n*np.exp(sc.gammaln((a+n+1)/b) - sc.gammaln(k))
def test_gammaincc_roundtrip(): a = np.logspace(-5, 10, 100) x = np.logspace(-5, 10, 100) y = sc.gammainccinv(a, sc.gammaincc(a, x)) assert_allclose(x, y, rtol=1e-14)
def main(top_block_cls=ROC_enDet, options=None): from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls() tb.start() tb.show() # By default the ROC_energy block is called in the calibration mode which estimates the noise floor # tb.set_center_freq(tb.get_center_freq()+4*tb.get_samp_rate()) # print(tb.get_center_freq()) sleep(3) # take 5 seconds of samples in the calibration mode # load the estimated noise value estN = scipy.fromfile(open( "C:\Users\usuario\Documents\gnuRadio\Misc\SpectrumSensing\P_absSq_exp.dat" ), dtype=scipy.float32) estN = np.mean(estN[np.abs(estN) >= 1e-15]) yy = scipy.fromfile(open( "C:\Users\usuario\Documents\gnuRadio\Misc\SpectrumSensing\P_var_reim_exp.dat" ), dtype=scipy.float32) yy = np.mean(yy[np.abs(yy) >= 1e-15]) zz = scipy.fromfile(open( "C:\Users\usuario\Documents\gnuRadio\Misc\SpectrumSensing\P_var_exp.dat" ), dtype=scipy.float32) zz = np.mean(zz[np.abs(zz) >= 1e-15]) print('Estimated noise floor in dB: ', estN, yy, zz) # tb.set_center_freq(tb.get_center_freq()-4*tb.get_samp_rate()) print('the center frequency is:', tb.get_center_freq()) # Reconfigure flow-graph # tb.lock() tb.stop() tb.wait() tb.disconnect((tb.ROC_energy_block, 0), (tb.blocks_file_sink_3, 0)) tb.disconnect((tb.ROC_energy_block, 1), (tb.blocks_file_sink_4, 0)) tb.disconnect((tb.ROC_energy_block, 2), (tb.blocks_file_sink_5, 0)) tb.disconnect((tb.null_source_0, 0), (tb.blocks_file_sink_0, 0)) tb.disconnect((tb.null_source_0, 0), (tb.blocks_file_sink_1, 0)) tb.disconnect((tb.null_source_0, 0), (tb.blocks_file_sink_2, 0)) # Connect the other sink blocks and restart tb.connect((tb.ROC_energy_block, 0), (tb.blocks_file_sink_0, 0)) tb.connect((tb.ROC_energy_block, 1), (tb.blocks_file_sink_1, 0)) tb.connect((tb.ROC_energy_block, 2), (tb.blocks_file_sink_2, 0)) tb.connect((tb.null_source_0, 0), (tb.blocks_file_sink_3, 0)) tb.connect((tb.null_source_0, 0), (tb.blocks_file_sink_4, 0)) tb.connect((tb.null_source_0, 0), (tb.blocks_file_sink_5, 0)) # tb.unlock() try: tb.start() except ValueError: print('Something went wrong') tb.set_fun('meas') # change to the 'measurement' mode # sleep(0.1) i = 0 for targPf in np.logspace( -6, 0, 21 ): # data with the first value of threshold is invalidated due to the noise floor new_thr = (10**(estN / 10)) * scpsp.gammainccinv(tb.get_N(), targPf) tb.set_thr(new_thr) # change threshold sleep(0.1) # run the flowgraph (with current values) for 3 seconds print(i, new_thr) i = i + 1 tb.stop() tb.wait() def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_()
def __init__(self): gr.top_block.__init__(self, "ROC curves energy detector") Qt.QWidget.__init__(self) self.setWindowTitle("ROC curves energy detector") qtgui.util.check_set_qss() try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "ROC_enDet") self.restoreGeometry(self.settings.value("geometry").toByteArray()) #################################################################################################### # Variables #################################################################################################### self.S = S = -75.0 # signal power in dBW self.w = w = -77.0 # noise power in dBW self.theta = theta = 0.0 # variable to simulate the presence or absence of signal self.sigma_s = sigma_s = 10**(S / 20.0) / np.sqrt( 2 ) # signal deviation (amplitude) of real and imaginary part in normalized Volts (referred to a 1 Ohm resistance) self.sigma_n = sigma_n = 10**( w / 20.0 ) # the sqrt(2) is an artifact of the channel that adds 3dB to the SNR (maybe the Linux version doesn't have this problem) self.samp_rate = samp_rate = 320000 self.N = N = 32 # number of samples # page size greatly limits this value, min page size seems to be the default 4096, then the buffer is formed in chunks of size [pagesize/N,N] self.targPf = targPf = 1e-7 # initial value, modified later within a loop to create the ROC curve self.thr = thr = sigma_n**2 * scpsp.gammainccinv( N, targPf) # threshold value for a target probability of false alarm #################################################################################################### # Blocks #################################################################################################### self.qtgui_time_sink_x_0 = qtgui.time_sink_f( 1024, #size samp_rate, #samp_rate "", #name 1 #number of inputs ) self.qtgui_time_sink_x_0.set_update_time(0.10) self.qtgui_time_sink_x_0.set_y_axis(-1, 1) self.qtgui_time_sink_x_0.set_y_label('Amplitude', "") self.qtgui_time_sink_x_0.enable_tags(-1, True) self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self.qtgui_time_sink_x_0.enable_autoscale(False) self.qtgui_time_sink_x_0.enable_grid(False) self.qtgui_time_sink_x_0.enable_axis_labels(True) self.qtgui_time_sink_x_0.enable_control_panel(False) if not True: self.qtgui_time_sink_x_0.disable_legend() labels = ['', '', '', '', '', '', '', '', '', ''] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ "blue", "red", "green", "black", "cyan", "magenta", "yellow", "dark red", "dark green", "blue" ] styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in xrange(1): if len(labels[i]) == 0: self.qtgui_time_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_time_sink_x_0.set_line_label(i, labels[i]) self.qtgui_time_sink_x_0.set_line_width(i, widths[i]) self.qtgui_time_sink_x_0.set_line_color(i, colors[i]) self.qtgui_time_sink_x_0.set_line_style(i, styles[i]) self.qtgui_time_sink_x_0.set_line_marker(i, markers[i]) self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_time_sink_x_0_win = sip.wrapinstance( self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_time_sink_x_0_win) self.channels_channel_model_0 = channels.channel_model( noise_voltage=sigma_n, frequency_offset=0.0, epsilon=1.0, taps=(1.0 + 1.0j, ), noise_seed=0, block_tags=False) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1, samp_rate, True) self.blocks_stream_to_vector_0 = blocks.stream_to_vector( gr.sizeof_gr_complex * 1, N) self.blocks_file_sink_0 = blocks.file_sink( gr.sizeof_float * 1, 'C:\\Users\\usuario\\Documents\\gnuRadio\\Misc\\SpectrumSensing\\N_det.dat', False) self.blocks_file_sink_0.set_unbuffered(True) self.blocks_file_sink_1 = blocks.file_sink( gr.sizeof_float * 1, 'C:\\Users\\usuario\\Documents\\gnuRadio\\Misc\\SpectrumSensing\\N_inD.dat', False) self.blocks_file_sink_1.set_unbuffered(True) self.blocks_file_sink_2 = blocks.file_sink( gr.sizeof_float * 1, 'C:\\Users\\usuario\\Documents\\gnuRadio\\Misc\\SpectrumSensing\\Thr.dat', False) self.blocks_file_sink_2.set_unbuffered(True) self.blocks_file_sink_3 = blocks.file_sink( gr.sizeof_float * 1, 'C:\\Users\\usuario\\Documents\\gnuRadio\\Misc\\SpectrumSensing\\P_var.dat', False) self.blocks_file_sink_3.set_unbuffered(True) self.blocks_file_sink_4 = blocks.file_sink( gr.sizeof_float * 1, 'C:\\Users\\usuario\\Documents\\gnuRadio\\Misc\\SpectrumSensing\\P_var_reim.dat', False) self.blocks_file_sink_4.set_unbuffered(True) self.blocks_file_sink_5 = blocks.file_sink( gr.sizeof_float * 1, 'C:\\Users\\usuario\\Documents\\gnuRadio\\Misc\\SpectrumSensing\\P_absSq.dat', False) self.blocks_file_sink_5.set_unbuffered(True) self.analog_noise_source_x_0 = analog.noise_source_c( analog.GR_GAUSSIAN, theta * sigma_s, 0) # self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate,analog.GR_COS_WAVE,1e3,theta*sigma_s, 0) # test for sinusoidal signals self.ROC_energy_block = ROC_energy_block.blk(N=N, thr=thr, fun='cal') #################################################################################################### # Connections #################################################################################################### self.connect((self.ROC_energy_block, 0), (self.blocks_file_sink_3, 0)) self.connect((self.ROC_energy_block, 1), (self.blocks_file_sink_4, 0)) self.connect((self.ROC_energy_block, 2), (self.blocks_file_sink_5, 0)) self.connect((self.ROC_energy_block, 0), (self.qtgui_time_sink_x_0, 0)) self.connect((self.analog_noise_source_x_0, 0), (self.blocks_throttle_0, 0)) # self.connect((self.analog_sig_source_x_0, 0), (self.blocks_throttle_0, 0)) # change to signal source self.connect((self.blocks_stream_to_vector_0, 0), (self.ROC_energy_block, 0)) self.connect((self.blocks_throttle_0, 0), (self.channels_channel_model_0, 0)) self.connect((self.channels_channel_model_0, 0), (self.blocks_stream_to_vector_0, 0))
def main(top_block_cls=ROC_enDet, options=None): from distutils.version import StrictVersion if StrictVersion(Qt.qVersion()) >= StrictVersion("4.5.0"): style = gr.prefs().get_string('qtgui', 'style', 'raster') Qt.QApplication.setGraphicsSystem(style) qapp = Qt.QApplication(sys.argv) tb = top_block_cls() tb.start() tb.show() # By default the ROC_energy block is called in the calibration mode which estimates the noise floor sleep(5) # take 5 seconds of samples in the calibration mode # load the estimated noise value estN = scipy.fromfile(open( "C:\Users\usuario\Documents\gnuRadio\Misc\SpectrumSensing\P_absSq.dat" ), dtype=scipy.float32) estN = np.mean(estN[np.abs(estN) >= 1e-15]) yy = scipy.fromfile(open( "C:\Users\usuario\Documents\gnuRadio\Misc\SpectrumSensing\P_var_reim.dat" ), dtype=scipy.float32) yy = np.mean(yy[np.abs(yy) >= 1e-15]) zz = scipy.fromfile(open( "C:\Users\usuario\Documents\gnuRadio\Misc\SpectrumSensing\P_var.dat"), dtype=scipy.float32) zz = np.mean(zz[np.abs(zz) >= 1e-15]) print('Estimated noise floor in dB: ', estN, yy, zz) # Reconfigure flow-graph # tb.lock() tb.stop() tb.wait() tb.disconnect((tb.ROC_energy_block, 0), (tb.blocks_file_sink_3, 0)) tb.disconnect((tb.ROC_energy_block, 1), (tb.blocks_file_sink_4, 0)) tb.disconnect((tb.ROC_energy_block, 2), (tb.blocks_file_sink_5, 0)) # Connect the other sink blocks and restart tb.connect((tb.ROC_energy_block, 0), (tb.blocks_file_sink_0, 0)) tb.connect((tb.ROC_energy_block, 1), (tb.blocks_file_sink_1, 0)) tb.connect((tb.ROC_energy_block, 2), (tb.blocks_file_sink_2, 0)) #tb.unlock() tb.start() tb.set_theta(1.0) # enable signal 'transmission' tb.set_fun('meas') # change to the 'measurement' mode # sleep(0.1) for targPf in np.logspace( -6, 0, 21 ): # data with the first value of threshold is invalidated due to the noise floor #new_thr = (10**(estN/10))*scpsp.gammainccinv(tb.get_N(), targPf) new_thr = tb.get_sigma_n()**2 * scpsp.gammainccinv( tb.get_N(), targPf) #use this for simulation accuracy tb.set_thr(new_thr) # change threshold sleep(1) # run the flowgraph (with current values) for 3 seconds tb.stop() tb.wait() def quitting(): tb.stop() tb.wait() qapp.connect(qapp, Qt.SIGNAL("aboutToQuit()"), quitting) qapp.exec_()
def radius(self, T, prec, deriv=[]): r""" Calculate the radius `R` to compute the value of the theta function to within `2^{-P + 1}` bits of precision where `P` is the real / complex precision given by the input matrix. Used primarily by ``RiemannTheta.integer_points()``. `R` is the radius of [CRTF] Theorems 2, 4, and 6. Input ----- - ``T`` -- the Cholesky decomposition of the imaginary part of the Riemann matrix `\Omega` - ``prec`` -- the desired precision of the computation - ``deriv`` -- (list) (default=``[]``) the derivative, if given. Radius increases as order of derivative increases. """ Pi = np.pi I = 1.0j g = np.float64(T.shape[0]) # compute the length of the shortest lattice vector #U = qflll(T) A = lattice_reduce(T) r = min(la.norm(A[:,i]) for i in range(int(g))) normTinv = la.norm(la.inv(T)) # solve for the radius using: # * Theorem 3 of [CRTF] (no derivative) # * Theorem 5 of [CRTF] (first order derivative) # * Theorem 7 of [CRTF] (second order derivative) if len(deriv) == 0: eps = prec lhs = eps * (2.0/g) * (r/2.0)**g * gamma(g/2.0) ins = gammainccinv(g/2.0,lhs) R = np.sqrt(ins) + r/2.0 rad = max( R, (np.sqrt(2*g)+r)/2.0) elif len(deriv) == 1: # solve for left-hand side L = self.deriv_accuracy_radius normderiv = la.norm(np.array(deriv[0])) eps = prec lhs = (eps * (r/2.0)**g) / (np.sqrt(Pi)*g*normderiv*normTinv) # define right-hand-side function involving the incomplete gamma # function def rhs(ins): """ Right-hand side function for computing the bounding ellipsoid radius given a desired maximum error bound for the first derivative of the Riemann theta function. """ return gamma((g+1)/2)*gammaincc((g+1)/2, ins) + \ np.sqrt(Pi)*normTinv*L * gamma(g/2)*gammaincc(g/2, ins) - \ float(lhs) # define lower bound (guess) and attempt to solve for the radius lbnd = np.sqrt(g+2 + np.sqrt(g**2+8)) + r try: ins = fsolve(rhs, float(lbnd))[0] except RuntimeWarning: # fsolve had trouble finding the solution. We try # a larger initial guess since the radius increases # as desired precision increases try: ins = fsolve(rhs, float(2*lbnd))[0] except RuntimeWarning: raise ValueError, "Could not find an accurate bound for the radius. Consider using higher precision." # solve for radius R = np.sqrt(ins) + r/2.0 rad = max(R,lbnd) elif len(deriv) == 2: # solve for left-hand side L = self.deriv_accuracy_radius prodnormderiv = np.prod([la.norm(d) for d in deriv]) eps = prec lhs = (eps*(r/2.0)**g) / (2*Pi*g*prodnormderiv*normTinv**2) # define right-hand-side function involving the incomplete gamma # function def rhs(ins): """ Right-hand side function for computing the bounding ellipsoid radius given a desired maximum error bound for the second derivative of the Riemann theta function. """ return gamma((g+2)/2)*gammaincc((g+2)/2, ins) + \ 2*np.sqrt(Pi)*normTinv*L * \ gamma((g+1)/2)*gammaincc((g+1)/2,ins) + \ Pi*normTinv**2*L**2 * \ gamma(g/2)*gammaincc(g/2,ins) - float(lhs) # define lower bound (guess) and attempt to solve for the radius lbnd = np.sqrt(g+4 + np.sqrt(g**2+16)) + r try: ins = fsolve(rhs, float(lbnd))[0] except RuntimeWarning: # fsolve had trouble finding the solution. We try # a larger initial guess since the radius increases # as desired precision increases try: ins = fsolve(rhs, float(2*lbnd))[0] except RuntimeWarning: raise ValueError, "Could not find an accurate bound for the radius. Consider using higher precision." # solve for radius R = np.sqrt(ins) + r/2.0 rad = max(R,lbnd) else: # can't computer higher derivatives, yet raise NotImplementedError("Ellipsoid radius for first and second derivatives not yet implemented.") return rad
def rchi2_given_prob(p, m, nu): a = (nu / 2.0) * np.float64(m) / (3.0 + np.float64(m)) return gammainccinv(a, p) / a
def _lower(self, a): return -special.gammainccinv(a, 2e-15)
def _logpdf(self, z, zm, a, b): k = (a+1)/b z0 = zm/sc.gammainccinv(k, 0.5)**(1/b) lognorm = np.log(b) - np.log(z0) - sc.gammaln(k) return lognorm + sc.xlogy(a, z/z0) - (z/z0)**b
def _ppf(self, q, a): fac = special.gammainccinv(a,1-abs(2*q-1)) return numpy.where(q>0.5, fac, -fac)
def _cdf(self, z, zm, a, b): k = (a+1)/b t = sc.gammainccinv(k, 0.5) return sc.gammainc(k, t*(z/zm)**b)
def _calc_sigma_from_cl(self): self._sigma = np.sqrt(2 * gammainccinv(self.ndim/2., 1. - self.cl))
def _ppf(self, q, zm, a, b): k = (a+1)/b t = sc.gammainccinv(k, 0.5) return zm*(sc.gammaincinv(k, q)/t)**(1/b)
def test_roundtrip(self): a = np.logspace(-5, 10, 100) x = np.logspace(-5, 10, 100) y = sc.gammainccinv(a, sc.gammaincc(a, x)) assert_allclose(x, y, rtol=1e-14)
def _rvs(self, zm, a, b): sz, rs = self._size, self._random_state k = (a+1)/b t = zm**b/sc.gammainccinv(k, 0.5) g = stats.gamma.rvs(k, scale=t, size=sz, random_state=rs) return g**(1/b)
def radius(self, T, prec, deriv=[]): r""" Calculate the radius `R` to compute the value of the theta function to within `2^{-P + 1}` bits of precision where `P` is the real / complex precision given by the input matrix. Used primarily by ``RiemannTheta.integer_points()``. `R` is the radius of [CRTF] Theorems 2, 4, and 6. Input ----- - ``T`` -- the Cholesky decomposition of the imaginary part of the Riemann matrix `\Omega` - ``prec`` -- the desired precision of the computation - ``deriv`` -- (list) (default=``[]``) the derivative, if given. Radius increases as order of derivative increases. """ Pi = np.pi I = 1.0j g = np.float64(T.shape[0]) # compute the length of the shortest lattice vector #U = qflll(T) A = lattice_reduce(T) r = min(la.norm(A[:,i]) for i in range(int(g))) normTinv = la.norm(la.inv(T)) # solve for the radius using: # * Theorem 3 of [CRTF] (no derivative) # * Theorem 5 of [CRTF] (first order derivative) # * Theorem 7 of [CRTF] (second order derivative if len(deriv) == 0: eps = prec lhs = eps * (2.0/g) * (r/2.0)**g * gamma(g/2.0) ins = gammainccinv(g/2.0,lhs) R = np.sqrt(ins) + r/2.0 rad = max( R, (np.sqrt(2*g)+r)/2.0) elif len(deriv) == 1: # solve for left-hand side L = self.deriv_accuracy_radius normderiv = la.norm(np.array(deriv[0])) eps = prec lhs = (eps * (r/2.0)**g) / (np.sqrt(Pi)*g*normderiv*normTinv) # define right-hand-side function involving the incomplete gamma # function def rhs(ins): """ Right-hand side function for computing the bounding ellipsoid radius given a desired maximum error bound for the first derivative of the Riemann theta function. """ return gamma((g+1)/2)*gammaincc((g+1)/2, ins) + \ np.sqrt(Pi)*normTinv*L * gamma(g/2)*gammaincc(g/2, ins) - \ float(lhs) # define lower bound (guess) and attempt to solve for the radius lbnd = np.sqrt(g+2 + np.sqrt(g**2+8)) + r try: ins = fsolve(rhs, float(lbnd))[0] except RuntimeWarning: # fsolve had trouble finding the solution. We try # a larger initial guess since the radius increases # as desired precision increases try: ins = fsolve(rhs, float(2*lbnd))[0] except RuntimeWarning: raise ValueError, "Could not find an accurate bound for the radius. Consider using higher precision." # solve for radius R = np.sqrt(ins) + r/2.0 rad = max(R,lbnd) elif len(deriv) == 2: # solve for left-hand side L = self.deriv_accuracy_radius prodnormderiv = np.prod([la.norm(d) for d in deriv]) eps = prec lhs = (eps*(r/2.0)**g) / (2*Pi*g*prodnormderiv*normTinv**2) # define right-hand-side function involving the incomplete gamma # function def rhs(ins): """ Right-hand side function for computing the bounding ellipsoid radius given a desired maximum error bound for the second derivative of the Riemann theta function. """ return gamma((g+2)/2)*gammaincc((g+2)/2, ins) + \ 2*np.sqrt(Pi)*normTinv*L * \ gamma((g+1)/2)*gammaincc((g+1)/2,ins) + \ Pi*normTinv**2*L**2 * \ gamma(g/2)*gammaincc(g/2,ins) - float(lhs) # define lower bound (guess) and attempt to solve for the radius lbnd = np.sqrt(g+4 + np.sqrt(g**2+16)) + r try: ins = fsolve(rhs, float(lbnd))[0] except RuntimeWarning: # fsolve had trouble finding the solution. We try # a larger initial guess since the radius increases # as desired precision increases try: ins = fsolve(rhs, float(2*lbnd))[0] except RuntimeWarning: raise ValueError, "Could not find an accurate bound for the radius. Consider using higher precision." # solve for radius R = np.sqrt(ins) + r/2.0 rad = max(R,lbnd) else: # can't computer higher derivatives, yet raise NotImplementedError("Ellipsoid radius for first and second derivatives not yet implemented.") return rad