diff --git a/.github/workflows/ci_tests.yml b/.github/workflows/ci_tests.yml index 6a3fb24..25d7624 100644 --- a/.github/workflows/ci_tests.yml +++ b/.github/workflows/ci_tests.yml @@ -18,8 +18,8 @@ jobs: strategy: matrix: os: [ubuntu-latest] - python: ['3.12', '3.13'] - deps: [current, numpy210, astropydev, numpydev, astropydev-numpydev] + python: ['3.12', '3.13', '3.14'] + deps: [current, numpy224, astropydev, numpydev, astropydev-numpydev] steps: - name: Check out repository @@ -34,10 +34,10 @@ jobs: python -m pip install git+https://github.com/FRBs/frb.git#egg=frb python -m pip install git+https://github.com/FRBs/ne2001.git#egg=ne2001 python -m pip install git+https://github.com/linetools/linetools#egg=linetools - - name: Test with numpy = 2.1.0 - if: "contains(matrix.deps, 'numpy210')" + - name: Test with numpy = 2.2.4 + if: "contains(matrix.deps, 'numpy224')" run: | - python -m pip install numpy==2.1.0 + python -m pip install numpy==2.2.4 - name: Test with dev version of numpy if: "contains(matrix.deps, 'numpydev')" run: | @@ -70,7 +70,7 @@ jobs: - name: Python codestyle check uses: actions/setup-python@v5 with: - python-version: '3.12' + python-version: '3.13' - name: Install base dependencies run: | python -m pip install --upgrade pip diff --git a/.gitignore b/.gitignore index 9481c69..d8ec7e2 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,8 @@ __pycache__/ *.png *.pdf *.csv +# ...but keep documentation figures (committed for the docs build) +!docs/figures/*.png papers/FRB_I/Analysis/SandBox/ papers/FRB_I/Resub/ papers/FRB_I/astroph/ diff --git a/astropath/bayesian.py b/astropath/bayesian.py index bd5dd7e..e2d959b 100644 --- a/astropath/bayesian.py +++ b/astropath/bayesian.py @@ -5,13 +5,87 @@ from astropy import units -from astropath import localization +from astropath import localization from IPython import embed +# Optional numba acceleration. numba need not be installed; when it is +# absent HAS_NUMBA is False and njit is a no-op decorator (the jitted +# kernel is simply never called -- callers fall back to numpy). +try: + from numba import njit + HAS_NUMBA = True +except ImportError: # numba not installed + HAS_NUMBA = False + + def njit(*args, **kwargs): + """No-op stand-in for numba.njit when numba is unavailable.""" + # Support both @njit and @njit(...) usage + if len(args) == 1 and callable(args[0]) and not kwargs: + return args[0] + + def _wrap(func): + return func + return _wrap + sqarcsec_steradians = 4 * np.pi * (1 / 3600 / 3600) / (180. / np.pi) ** 2 +# PDF integer codes shared by pw_Oi and the numba kernel +_PDF_CORE = 0 +_PDF_UNIFORM = 1 +_PDF_EXP = 2 + + +def _resolve_offset_prior(phi, theta_prior): + """Resolve the offset prior to plain scalars (single source). + + Centralizes the offset-PDF normalization and parameters so that the + pure-numpy ``pw_Oi`` and the numba kernel share one definition. + + Args: + phi (float): + Angular size of the galaxy in arcsec. + theta_prior (dict): + Offset-prior parameters (keys: PDF, max, and scale for exp). + + Returns: + tuple: (pdf_code, theta_max, kparam, norm) + pdf_code (int): One of _PDF_CORE/_PDF_UNIFORM/_PDF_EXP. + theta_max (float): Cutoff offset (arcsec); p=0 beyond it. + kparam (float): PDF scale param -- phi for core, phi*scale + for exp, unused (=phi) for uniform. + norm (float): Normalization so the PDF integrates to 1. + """ + pdf = theta_prior['PDF'] + # Cutoff always uses the ORIGINAL phi (matches the legacy pw_Oi, + # where ok_w is computed before phi is rescaled for the exp PDF). + theta_max = theta_prior['max'] * phi + if pdf == 'core': + pdf_code = _PDF_CORE + kparam = phi + # Wolfram; updated by JXP on 14-Feb-2023 + term0 = -1 * phi**2 * np.log(phi) + term_max = phi * (theta_prior['max']*phi + - phi*np.log(phi+theta_prior['max']*phi)) + norm = 2*np.pi*(term_max - term0) + elif pdf == 'uniform': + pdf_code = _PDF_UNIFORM + kparam = phi # unused by the uniform PDF + norm = np.pi * (phi*theta_prior['max'])**2 + elif pdf == 'exp': + pdf_code = _PDF_EXP + # exp decay length is phi*scale; cutoff stays at max*phi above + kparam = phi * theta_prior['scale'] + # Need to also adjust to max/scale for correct normalization + max_eff = theta_prior['max'] / theta_prior['scale'] + norm = 2 * np.pi * kparam**2 * (1 - (1+max_eff)*np.exp( + -max_eff)) + else: + raise IOError("Bad theta PDF") + return pdf_code, theta_max, kparam, norm + + def pw_Oi(theta, phi, theta_prior): """ Calculate p(w|O_i) for a given galaxy @@ -32,41 +106,88 @@ def pw_Oi(theta, phi, theta_prior): np.ndarray: Probability values without grid-size normalization """ - p = np.zeros_like(theta) - ok_w = theta < theta_prior['max']*phi - if theta_prior['PDF'] == 'core': - # Wolfram - # Updated by JXP on 14-Feb-2023 - term0 = -1 * phi**2 * np.log(phi) - term_max = phi * (theta_prior['max']*phi - phi*np.log(phi+theta_prior['max']*phi)) - norm = 2*np.pi*(term_max - term0) - # - if np.any(ok_w): - p[ok_w] = phi / (theta[ok_w] + phi) / norm - elif theta_prior['PDF'] == 'uniform': - norm = np.pi * (phi*theta_prior['max'])**2 - if np.any(ok_w): - p[ok_w] = 1. / norm - elif theta_prior['PDF'] == 'exp': - # Wolfram - phi = phi * theta_prior['scale'] - # Updated by JXP on 14-Feb-2023 - norm = 2 * np.pi * phi**2 * (1 - (1+theta_prior['max'])*np.exp( - -theta_prior['max'])) - if np.any(ok_w): - p[ok_w] = np.exp(-theta[ok_w]/phi) / norm - else: - raise IOError("Bad theta PDF") + # Resolve PDF code + normalization once (single-sourced, also used + # by the numba kernel). kparam = phi (core) or phi*scale (exp). + pdf_code, theta_max, kparam, norm = _resolve_offset_prior( + phi, theta_prior) # if norm == 0: raise ValueError("You forgot to normalize!") + p = np.zeros_like(theta) + ok_w = theta < theta_max + if np.any(ok_w): + if pdf_code == _PDF_CORE: + p[ok_w] = kparam / (theta[ok_w] + kparam) / norm + elif pdf_code == _PDF_UNIFORM: + p[ok_w] = 1. / norm + else: # _PDF_EXP + p[ok_w] = np.exp(-theta[ok_w]/kparam) / norm # Return return p -def px_Oi_fixedgrid(box_hwidth, localiz, cand_coords, - cand_ang_size, theta_prior, step_size=0.1, - return_grids=False): +@njit(cache=True) +def px_Oi_numba(ra, dec, L_wx, cand_ra, cand_dec, cos_dec, + pdf_code, theta_max, kparam, norm, spacing): + """Numba kernel: p(x|O_i) for a SINGLE candidate (fused, 1 pass). + + Computes the flat-sky offset theta, the offset PDF p(w|O_i), the + product with L(w-x), and the grid sum in one loop over pixels -- + avoiding the full-grid temporaries (theta, p_wOi, grid_p) that the + numpy path allocates per candidate. Single-threaded @njit. + + Kept separate from ``px_Oi_fixedgrid`` (which orchestrates the grid, + L_wx, and the candidate loop) and from ``pw_Oi`` (pure-numpy PDF). + + Args: + ra (np.ndarray): 2D grid of RA (deg). + dec (np.ndarray): 2D grid of Dec (deg). + L_wx (np.ndarray): 2D localization term on the same grid. + cand_ra (float): Candidate RA (deg). + cand_dec (float): Candidate Dec (deg). + cos_dec (float): cos(candidate Dec) for flat-sky scaling. + pdf_code (int): Offset-PDF code (see _resolve_offset_prior). + theta_max (float): Cutoff offset (arcsec). + kparam (float): PDF scale param (phi or phi*scale). + norm (float): PDF normalization. + spacing (float): Grid spacing (arcsec); result scales by its + square. + + Returns: + tuple: (p_xOi, pw_sum) + p_xOi (float): UNcorrected p(x|O_i) for the candidate + (= sum of L_wx*p(w|O_i) over the grid, times spacing^2). + pw_sum (float): Sum of p(w|O_i) over the grid. Returned so + ``px_Oi_fixedgrid`` can apply the optional 'p_wO' + correction with the same formula as the numpy path. + """ + nrow, ncol = ra.shape + acc = 0.0 + pw_sum = 0.0 # sum of p(w|O_i) over the grid, for the p_wO correction + for i in range(nrow): + for j in range(ncol): + dra = ra[i, j] - cand_ra + ddec = dec[i, j] - cand_dec + # flat-sky offset in arcsec + theta = 3600.0 * np.sqrt( + cos_dec * cos_dec * dra * dra + ddec * ddec) + if theta < theta_max: + if pdf_code == _PDF_CORE: + pw = kparam / (theta + kparam) / norm + elif pdf_code == _PDF_UNIFORM: + pw = 1.0 / norm + else: # _PDF_EXP + pw = np.exp(-theta / kparam) / norm + acc += L_wx[i, j] * pw + pw_sum += pw # p(w|O_i)=0 outside support, so this is + # the full-grid sum + return acc * spacing * spacing, pw_sum + + +def px_Oi_fixedgrid(box_hwidth, localiz, cand_coords, + cand_ang_size, theta_prior, step_size=0.1, + return_grids=False, return_debug:bool=False, + use_numba:bool=False, correction:str=None): """ Calculate p(x|O_i), the primary piece of the analysis @@ -91,6 +212,18 @@ def px_Oi_fixedgrid(box_hwidth, localiz, cand_coords, Step size for grid, in arcsec return_grids (bool, optional): if True, return the calculation grid + return_debug (bool, optional): + if True, return intermediate grids for debugging + use_numba (bool, optional): + if True, evaluate the per-candidate loop with the numba + ``px_Oi`` kernel (single-threaded @njit). Defaults to + False. Silently falls back to the numpy path if numba is + not installed, or if return_grids/return_debug is set (the + fused kernel does not build per-pixel grids). + correction (str, optional): Correction to apply to the posteriors + 'p_wO' -- Correct p(w|O) + 'L_wx' -- Correct L(w-x) + None -- No correction Returns: np.ndarray or tuple: p(x|O_i) values and the grids if return_grids = True @@ -101,9 +234,6 @@ def px_Oi_fixedgrid(box_hwidth, localiz, cand_coords, # raise IOError("To use this method, you need to specfic a center for the fixed grid via center_coord in localiz") - # Set Equinox (for spherical offsets) - localiz['center_coord'].equinox = cand_coords[0].equinox - # Build the fixed grid around the transient ngrid = int(np.round(2*box_hwidth / step_size)) x = np.linspace(-box_hwidth, box_hwidth, ngrid) @@ -112,22 +242,75 @@ def px_Oi_fixedgrid(box_hwidth, localiz, cand_coords, # Grid spacing grid_spacing_arcsec = x[1]-x[0] + # Extract the center coordinate once as plain numpy floats. Avoids + # repeated astropy attribute/Quantity access. The previous + # equinox-setting line was dropped: it is a no-op for the numpy + # paths (offsets here are flat-sky; calc_LWx ignores equinox). + center_ra = localiz['center_coord'].ra.deg # deg + center_dec = localiz['center_coord'].dec.deg # deg + cos_center_dec = np.cos(np.radians(center_dec)) # flat-sky scaling + # ##################### # L(w-x) -- 2D Gaussian, normalized to 1 when integrating over x not omega # Approximate as flat sky # Warning: RA increases in x for these grids!! - ra = localiz['center_coord'].ra.deg + \ - xcoord/3600. / np.cos(localiz['center_coord'].dec).value - dec = localiz['center_coord'].dec.deg + ycoord/3600. - L_wx = localization.calc_LWx(ra, dec, localiz) + print('Calculating L(w-x)') + ra = center_ra + xcoord/3600. / cos_center_dec + dec = center_dec + ycoord/3600. + L_wx = localization.calc_LWx(ra, dec, localiz) + # Prep for correction + if correction == 'L_wx': + corr_Lwx = np.sum(L_wx) * grid_spacing_arcsec**2 + + # Pre-extract candidate coordinates to numpy arrays ONCE (numpy + # only). Iterating a SkyCoord array and reading .ra/.dec per + # candidate is the dominant astropy overhead in this loop; pulling + # them out here removes it. Working with plain arrays/floats also + # keeps the inner loop numba-friendly for a future @njit speed-up. + cand_ra = cand_coords.ra.deg # deg, shape (N,) + cand_dec = cand_coords.dec.deg # deg, shape (N,) + cos_cand_dec = np.cos(np.radians(cand_dec)) # flat-sky scaling + + # The fused numba kernel returns only the scalar p(x|O_i); it cannot + # build per-pixel grids, so disable it when those are requested. + # Warn (don't error) if numba was asked for but isn't installed. + use_numba_eff = use_numba and not return_grids and not return_debug + if use_numba and not HAS_NUMBA: + warnings.warn("use_numba=True but numba is not installed; " + "falling back to numpy.") + use_numba_eff = False + if use_numba_eff: + print('Using numba for the posterior calculation') p_xOis, grids = [], [] - # TODO -- multiprocess this - for icand, cand_coord in enumerate(cand_coords): + # TODO -- multiprocess this? + print('Looping on candidates') + for icand in range(cand_ra.size): + if icand % 50 == 0: + print(f'icand: {icand}') + + if use_numba_eff: + # Resolve the prior to scalars, then fuse theta/PDF/product/ + # sum in one numba pass (no full-grid temporaries). + pdf_code, theta_max, kparam, norm = _resolve_offset_prior( + cand_ang_size[icand], theta_prior) + p_val, pw_sum = px_Oi_numba( + ra, dec, L_wx, cand_ra[icand], cand_dec[icand], + cos_cand_dec[icand], pdf_code, theta_max, kparam, norm, + grid_spacing_arcsec) + # Apply the SAME optional correction as the numpy path. + # Dividing the grid by a scalar then summing == dividing the + # sum, so we correct the scalar p(x|O_i) directly. + if correction == 'p_wO': + p_val /= pw_sum * grid_spacing_arcsec**2 + elif correction == 'L_wx': + p_val /= corr_Lwx + p_xOis.append(p_val) + continue # Offsets from the transient (approximate + flat sky) - theta = 3600*np.sqrt(np.cos(cand_coord.dec).value**2 * ( - ra-cand_coord.ra.deg)**2 + (dec-cand_coord.dec.deg)**2) # arc sec + theta = 3600*np.sqrt(cos_cand_dec[icand]**2 * ( + ra-cand_ra[icand])**2 + (dec-cand_dec[icand])**2) # arc sec # p(w|O_i) p_wOi = pw_Oi(theta, @@ -137,27 +320,146 @@ def px_Oi_fixedgrid(box_hwidth, localiz, cand_coords, # Product grid_p = L_wx * p_wOi + # Save grids if returning if return_grids: grids.append(grid_p.copy()) # Sum - p_xOis.append(np.sum(grid_p)*grid_spacing_arcsec**2) + p_val = np.sum(grid_p)*grid_spacing_arcsec**2 + + # Correction + if correction == 'p_wO': + p_val /= np.sum(p_wOi) * grid_spacing_arcsec**2 + elif correction == 'L_wx': + p_val /= corr_Lwx + + #embed(header='336 of bayesian.py') + p_xOis.append(p_val) # Return if return_grids: return np.array(p_xOis), grids + elif return_debug: + return L_wx, p_wOi, grid_p, p_xOis[0] else: return np.array(p_xOis) +def _Lwx_correction(E0, N0, a, b, cos_dth, sin_dth, box_hwidth, + ngrid, step_size_phi, max_side:int=5000): + """Localization normalization factor for an under-resolved L(w-x). + + Fast companion to ``px_Oi_local`` for the ``b < phi`` regime. There + the galaxy-centered grid (spacing ``step_size_phi``) deliberately + UNDER-resolves the sharp localization, so the discrete ``sum(L_wx)`` + -- and hence the raw p(x|O_i) -- comes out below its true value. + This returns the discrete integral of L(w-x), the "total L_wx", on a + grid that: + + * is CENTERED ON THE LOCALIZATION (the transient), covering a + SQUARE window of half-width ``4*a`` (>= 4 sigma of the major + axis, so it captures essentially all of the ellipse); + * has EXACTLY the galaxy-grid spacing, and lies ON the galaxy + lattice -- it is the galaxy grid shifted by an integer number of + cells. The localization is therefore sampled at the SAME + sub-cell phase as the main grid, so the under-resolution aliasing + is identical in the raw sum and in this factor. + + The caller divides the raw p(x|O_i) by this factor, which cancels the + aliasing bias (accurate to ~1%) -- the same idea as + ``px_Oi_fixedgrid``'s ``correction='L_wx'``, but with a coarse, + galaxy-aligned grid instead of a fine one. + + Memory guard: the window has ~``8*a/step_size_phi`` cells per side. + This only exceeds ``max_side`` when ``step_size_phi`` is very small + -- i.e. when the galaxy grid ALREADY resolves L and the raw value + needs no correction -- so in that case we skip (return 1.0) rather + than allocate a huge array. + + Args: + E0 (float): East offset of the galaxy from the localization + center, arcsec (flat sky). + N0 (float): North offset of the galaxy from the localization + center, arcsec. + a (float): Localization ellipse semi-major axis, arcsec. + b (float): Localization ellipse semi-minor axis, arcsec. + cos_dth (float): cos of the ellipse-frame rotation (90 - PA), + shared with the main loop. + sin_dth (float): sin of the same rotation. + box_hwidth (float): Half-width of the galaxy grid, arcsec + (= phi*max); recovers the galaxy lattice with ``ngrid``. + ngrid (int): Cells per side of the galaxy grid (built as + ``linspace(-box_hwidth, box_hwidth, ngrid)``). + step_size_phi (float): Galaxy-grid spacing, arcsec + (= phi*step_size); used for the area element dA so the factor + matches the caller's raw sum. + max_side (int, optional): Skip (return 1.0) if the window would + exceed this many cells per side. Default 5000. + + Returns: + float: The discrete ``sum(L_wx)*dA`` ("total L_wx"; ~1 when + resolved, < 1 when under-resolved), or 1.0 if skipped. + """ + # Exact galaxy-grid spacing (linspace of ngrid points on [-box,box]). + h = 2. * box_hwidth / (ngrid - 1) + # Half-window in cells to reach 4 sigma along the major axis (4*a). + m = int(np.ceil(4. * a / h)) + # Skip if the window would be huge: that happens when h << a at fine + # step, i.e. L is already well resolved on the galaxy grid and the + # raw value needs no correction. Avoids allocating a huge array. + # TODO -- consider still making a correction but with a smaller window + if (2 * m + 1) > max_side: + return 1.0 + # Snap the localization onto the galaxy lattice (integer cell shift). + # Galaxy-frame lattice points (offsets from the galaxy) are + # -box_hwidth + k*h; the transient sits at offset (-E0, -N0). + kE = int(np.round((box_hwidth - E0) / h)) + kN = int(np.round((box_hwidth - N0) / h)) + idx = np.arange(-m, m + 1) + cE = -box_hwidth + (kE + idx) * h # offsets from galaxy (E) + cN = -box_hwidth + (kN + idx) * h # offsets from galaxy (N) + CE, CN = np.meshgrid(cE, cN) + # Offset of each cell from the localization center, rotated into the + # ellipse frame; same 2D Gaussian L(w-x) as the main loop. + E = E0 + CE + N = N0 + CN + x_box = E * cos_dth + N * sin_dth + y_box = N * cos_dth - E * sin_dth + L_wx = (np.exp(-x_box ** 2 / (2 * a ** 2)) + * np.exp(-y_box ** 2 / (2 * b ** 2)) / (2 * np.pi * a * b)) + # "Total L_wx" -- the discrete integral with the SAME dA as the raw + # galaxy-grid sum, so dividing the raw by it cancels the aliasing. + return np.sum(L_wx) * step_size_phi ** 2 + + def px_Oi_local(localiz, cand_coords, cand_ang_size, - theta_prior, step_size=0.1, debug = False): + theta_prior, step_size=0.05, + step_size_mode:str='relative', + debug = False): """ Perform the calculation on local grids, one - per candidate. This is likely slower than + per candidate. This is likely slower than the "fixed" method, but best for large localization areas which cover a large area of the sky. - + + The ``eellipse`` localization type uses a fast pure-numpy, flat-sky + path (see notes below); all other types fall back to the generic + ``localization.calc_LWx`` lookup. Either way the only astropy access + is a single up-front extraction of the candidate and center + coordinates -- the per-candidate loop is pure numpy (and structured + so a numba kernel can later replace its body; cf. ``px_Oi_numba``). + + Notes (eellipse fast path): + * The per-candidate grid is built ONCE in normalized units. + Because ``box_hwidth = phi*max`` and the spacing is + ``phi*step_size``, the pixel count ``ngrid = 2*max/step_size`` + is the SAME for every candidate, so the normalized grid + (U, V, R) is reused and merely rescaled by ``phi*max``. + * L(w-x) for the error ellipse is evaluated directly in the + flat-sky tangent plane (offsets in arcsec, rotated into the + ellipse frame), avoiding astropy's spherical separation / + position-angle machinery. This matches calc_LWx's eellipse + result to ~1e-5 fractionally at arcsec grid scales. Args: localiz (dict): @@ -178,60 +480,147 @@ def px_Oi_local(localiz, cand_coords, cand_ang_size, If true, hit an embed in the main loop Returns: - np.ndarray or tuple: p(x|O_i) values and the grids if return_grids = True + np.ndarray: p(x|O_i) values, one per candidate. """ + # Pre-extract candidate coordinates to plain numpy arrays ONCE. + # Iterating a SkyCoord and reading .ra/.dec per candidate is the + # dominant astropy overhead; pulling them out here removes it and + # keeps the loop numba-friendly. + cand_ra = cand_coords.ra.deg # deg, shape (N,) + cand_dec = cand_coords.dec.deg # deg, shape (N,) + cos_cand_dec = np.cos(np.radians(cand_dec)) # flat-sky scaling + + # Normalized grid, built ONCE. ngrid depends only on max/step_size + # (phi cancels), so the same grid serves every candidate. U, V span + # [-1, 1]; the physical grid is phi*max * (U, V) and theta = phi*max*R. + max_theta = theta_prior['max'] + if step_size_mode == 'relative': + ngrid = int(np.round(2 * max_theta / step_size)) + u = np.linspace(-1., 1., ngrid) + Ugrid, Vgrid = np.meshgrid(u, u) + Rgrid = np.sqrt(Ugrid ** 2 + Vgrid ** 2) # normalized radius + else: + raise ValueError(f"Invalid step_size_mode: {step_size_mode}") + + # Pre-compute the eellipse constants once (flat-sky fast path). + is_eellipse = localiz['type'] == 'eellipse' + if is_eellipse: + # Pre-extract the localization center once (eellipse only; other + # types have no center_coord and resolve L_wx via calc_LWx). + center_ra = localiz['center_coord'].ra.deg # deg + center_dec = localiz['center_coord'].dec.deg # deg + cos_center_dec = np.cos(np.radians(center_dec)) # flat-sky scale + ell = localiz['eellipse'] + a = ell['a'] + b = ell['b'] + # Rotation that places the ellipse major axis on the x-axis; + # identical convention to localization.calc_LWx (dtheta=90-PA). + dth = np.radians(90. - ell['theta']) + cos_dth = np.cos(dth) + sin_dth = np.sin(dth) + inv_2a2 = 1. / (2 * a ** 2) + inv_2b2 = 1. / (2 * b ** 2) + L_norm = 1. / (2 * np.pi * a * b) + # Loop on galaxies p_xOis = [] - # TODO -- parallelize this - for icand, cand_coord in enumerate(cand_coords): - # Prep - phi_cand = cand_ang_size[icand] # arcsec - step_size_phi = phi_cand * step_size # arcsec - box_hwidth = phi_cand * theta_prior['max'] # arcsec - - # Grid around the galaxy - ngrid = int(np.round(2 * box_hwidth / step_size_phi)) - x = np.linspace(-box_hwidth, box_hwidth, ngrid) - xcoord, ycoord = np.meshgrid(x,x) - theta = np.sqrt(xcoord**2 + ycoord**2) + # TODO -- parallelize / numba this per-candidate body + for icand in range(cand_ra.size): + + # Prep -- scale the normalized grid to this galaxy's size + phi_cand = cand_ang_size[icand] # arcsec + box_hwidth = phi_cand * max_theta # arcsec + step_size_phi = phi_cand * step_size # arcsec + + xcoord = box_hwidth * Ugrid # east offset, arcsec + ycoord = box_hwidth * Vgrid # north offset, arcsec + theta = box_hwidth * Rgrid # arcsec + # p(w|O) p_wOi = pw_Oi(theta, phi_cand, theta_prior) - # Generate coords for transient localiation (flat sky) - ra = cand_coord.ra.deg + \ - xcoord/3600. / np.cos(cand_coord.dec).value - dec = cand_coord.dec.deg + ycoord/3600. - - # Calculate - L_wx = localization.calc_LWx(ra, dec, localiz) + if is_eellipse: + # Flat-sky offsets of the galaxy center from the transient + # center (arcsec): east scaled by cos(dec), north direct. + E0 = (cand_ra[icand] - center_ra) * cos_center_dec * 3600. + N0 = (cand_dec[icand] - center_dec) * 3600. + # Offsets of every grid point from the transient center + E = E0 + xcoord # east, arcsec + N = N0 + ycoord # north, arcsec + # Rotate into the ellipse frame (x along the major axis). + # Signs are squared below, so they need not match calc_LWx. + x_box = E * cos_dth + N * sin_dth + y_box = N * cos_dth - E * sin_dth + # 2D Gaussian L(w-x), normalized over x (not omega) + L_wx = (np.exp(-x_box ** 2 * inv_2a2) + * np.exp(-y_box ** 2 * inv_2b2) * L_norm) + + # Correction: when the localization minor axis b is smaller + # than the galaxy size phi, the galaxy-centered grid + # under-resolves the sharp localization and the raw sum is + # biased low. Divide by the "total L_wx" computed on a + # localization-centered, galaxy-aligned grid so the aliasing + # cancels (see _Lwx_correction). + if b < phi_cand: + L_wx_correction = _Lwx_correction( + E0, N0, a, b, cos_dth, sin_dth, box_hwidth, + ngrid, step_size_phi) + # Degenerate case: the localization is so much smaller + # than the grid spacing that even the aligned correction + # grid catches no flux -- the factor underflows to 0 and + # the raw sum is 0 too (0/0). Fall back to the + # delta-function limit p(x|O_i) = p(w=x|O_i), which is + # exact as b -> 0 since L integrates to 1. + if not (L_wx_correction > 0.): + theta0 = np.sqrt(E0 ** 2 + N0 ** 2) # offset, arcsec + p_xOis.append(pw_Oi( + np.array([theta0]), phi_cand, theta_prior)[0]) + if debug: + embed(header='px_Oi_local delta-limit') + continue + else: + L_wx_correction = 1.0 + + else: + # Generic fallback (healpix/wcs): build flat-sky coords and + # use calc_LWx, which does the type-specific lookup. No + # under-resolution correction here (eellipse only). + ra = (cand_ra[icand] + + xcoord / 3600. / cos_cand_dec[icand]) + dec = cand_dec[icand] + ycoord / 3600. + L_wx = localization.calc_LWx(ra, dec, localiz) + L_wx_correction = 1.0 # Finish - grid_p = L_wx * p_wOi - # - p_xOis.append(np.sum(grid_p)*step_size_phi**2) + grid_p = L_wx * p_wOi / L_wx_correction + p_xOis.append(np.sum(grid_p) * step_size_phi ** 2) # Debug if debug: - embed(header='207 of bayesian.py') + embed(header='px_Oi_local of bayesian.py') # Return return np.array(p_xOis) -def px_U(box_hwidth): +def px_U(radius:float): """ Args: - box_hwidth (float): - Half-width of the analysis box, in arcsec + radius (float): + Radius of the area enclosing the candidates + in arcsec Returns: - float: p(x|U) + float: p(x|U) in inverse squarearcsec + This is the same convention as p(x|O) as it must """ - box_sqarcsec = (2*box_hwidth)**2 + #box_sqarcsec = (2*box_hwidth)**2 #box_steradians = box_sqarcsec * sqarcsec_steradians + area = np.pi * radius**2 # - return 1./box_sqarcsec # box_steradians + #return 1./box_sqarcsec # box_steradians + return 1./area diff --git a/astropath/localization.py b/astropath/localization.py index 996d7ff..3e22d79 100644 --- a/astropath/localization.py +++ b/astropath/localization.py @@ -63,18 +63,42 @@ def calc_LWx(ra:np.ndarray, dec:np.ndarray, localiz:dict): if localiz['type'] == 'eellipse': # Setup eellipse = localiz['eellipse'] # convenience - pa_ee = eellipse['theta'] # PA of error ellipse on the sky; deg - dtheta = 90. - pa_ee # Rotation to place the semi-major axis "a" of the ellipse along the x-axis we define + pa_ee = eellipse['theta'] # PA of error ellipse on the sky; deg + # Rotation to place the semi-major axis "a" of the ellipse along + # the x-axis we define + dtheta = 90. - pa_ee # - coord = SkyCoord(ra=ra, dec=dec, unit='deg') - coord.equinox = localiz['center_coord'].equinox - # Rotate to the transient frame - sep_box = localiz['center_coord'].separation(coord).to('arcsec') - pa_box = localiz['center_coord'].position_angle(coord).to('deg') - new_pa_box = pa_box + dtheta * units.deg + # Pure-numpy replacement for the astropy SkyCoord/separation/ + # position_angle calls (see Logs in prompts/speed_up.md). We + # reproduce astropy.coordinates.angle_utilities exactly with + # numpy, avoiding SkyCoord construction and Quantity overhead. + # Equinox is irrelevant: ICRS separation/PA do not depend on it. + ra0 = np.radians(localiz['center_coord'].ra.deg) # center RA, rad + dec0 = np.radians(localiz['center_coord'].dec.deg) # center Dec, rad + ra_r = np.radians(ra) # grid RA, rad + dec_r = np.radians(dec) # grid Dec, rad + # Trig terms shared by the separation and position-angle formulae + dlon = ra_r - ra0 + sdlon = np.sin(dlon) + cdlon = np.cos(dlon) + sl1 = np.sin(dec0) + cl1 = np.cos(dec0) + sl2 = np.sin(dec_r) + cl2 = np.cos(dec_r) + # Vincenty angular separation (rad) -> arcsec. Matches + # SkyCoord.separation to ~1e-10 arcsec. + sep = np.arctan2( + np.hypot(cl2 * sdlon, cl1 * sl2 - sl1 * cl2 * cdlon), + sl1 * sl2 + cl1 * cl2 * cdlon) + sep_box = np.degrees(sep) * 3600. # arcsec + # Position angle East of North (rad). Matches + # SkyCoord.position_angle to ~1e-8 deg. + pa_box = np.arctan2(sdlon * cl2, sl2 * cl1 - cl2 * sl1 * cdlon) + # Rotate to the transient frame (dtheta given in deg) + new_pa_box = pa_box + np.radians(dtheta) # x, y of the box in transient frame with x along major axis - x_box = -sep_box.value * np.sin(new_pa_box).value - y_box = sep_box.value * np.cos(new_pa_box).value + x_box = -sep_box * np.sin(new_pa_box) + y_box = sep_box * np.cos(new_pa_box) # Calculate L_wx = np.exp(-x_box ** 2 / (2 * eellipse['a'] ** 2)) * np.exp( diff --git a/astropath/path.py b/astropath/path.py index d9a42a1..53d57c5 100644 --- a/astropath/path.py +++ b/astropath/path.py @@ -163,8 +163,14 @@ def calc_priors(self, ifilter:str='r'): # Return them too return self.prior_Oi - def calc_posteriors(self, method:str, step_size=0.1, box_hwidth=None, - max_radius=None, debug:bool=False): + def calc_posteriors(self, method:str, + step_size:float=0.05, + box_hwidth=None, + survey_radius:float=None, + step_size_mode:str='relative', + use_numba:bool=False, + debug:bool=False, + correction:str=None): """Calculate the posteriors Args: @@ -173,10 +179,17 @@ def calc_posteriors(self, method:str, step_size=0.1, box_hwidth=None, local -- One grid is generated for each candidate step_size (float, optional): [description]. Defaults to 0.1. box_hwidth (float, optional): [description]. Defaults to None. - max_radius (float, optional): Maximum radius (arcsec) + survey_radius (float, optional): Maximum radius (arcsec) allowed for galaxy. Only required for cases where P(U)>0. + use_numba (bool, optional): Use numba for calculations. Default False. debug (bool, optional): Debug + correction (str, optional): Correction to apply to the posteriors + 'p_wO' -- Correct p(w|O) + 'L_wx' -- Correct L(w-x) + step_size_mode (str, optional): Mode for step size + 'relative' -- Step size is relative to the galaxy size + 'absolute' -- Step size is absolute in arcsec [not recommended] Raises: IOError: [description] @@ -195,6 +208,7 @@ def calc_posteriors(self, method:str, step_size=0.1, box_hwidth=None, if 'P_O' not in self.candidates.keys(): raise ValueError("You need to calculate the candidate priors first!!") + #embed(header='path.py:211') # P(x|O) logging.info("Calculating p(x|O)") if method == 'fixed': @@ -205,7 +219,9 @@ def calc_posteriors(self, method:str, step_size=0.1, box_hwidth=None, self.cand_coords, self.candidates['ang_size'].values, self.theta_prior, - step_size=step_size) + step_size=step_size, + use_numba=use_numba, + correction=correction) elif method == 'local': self.p_xOi = bayesian.px_Oi_local( self.localiz, @@ -213,20 +229,21 @@ def calc_posteriors(self, method:str, step_size=0.1, box_hwidth=None, self.candidates['ang_size'].values, self.theta_prior, step_size=step_size, + step_size_mode=step_size_mode, debug=debug) self.candidates['p_xO'] = self.p_xOi # P(U|x) logging.info("Calculating p(x|U)") if self.cand_prior['P_U'] > 0.: - if max_radius is None: - raise IOError("Set max_radius given that P(U) > 0!!") + if survey_radius is None: + raise IOError("Set survey_radius given that P(U) > 0!!") if self.cand_prior['P_O_method']=='user': # leave unmodified self.p_xU = 1 else: # downweight by FOV - self.p_xU = bayesian.px_U(max_radius) + self.p_xU = bayesian.px_U(survey_radius) else: self.p_xU = 0. diff --git a/astropath/profiling.py b/astropath/profiling.py new file mode 100644 index 0000000..decb8d9 --- /dev/null +++ b/astropath/profiling.py @@ -0,0 +1,511 @@ +""" Profiling utilities for the PATH calculations. + +This module times the two core PATH steps that were targeted for the +numpy speed-up work (see prompts/speed_up.md): + + * ``localization.calc_LWx`` -- the localization term L(w-x) + * ``bayesian.px_Oi_fixedgrid`` -- the fixed-grid p(x|O_i) + +It is modeled on the ``calculations/step_size/Profiling.ipynb`` +notebook: a faux FRB, a circular error ellipse, and a couple of +candidate galaxies. Rather than timing each sub-step interactively, it +sweeps a range of grid sizes (by varying ``step_size``), builds a table +of timings, prints it, and writes a figure. + +Run from the command line:: + + python -m astropath.profiling + +or import and call :func:`run_profiling` directly. +""" +import os +import time + +import numpy as np +import pandas + +import matplotlib +matplotlib.use('Agg') # headless-safe; no interactive display needed +import matplotlib.pyplot as plt # noqa: E402 + +from astropy.coordinates import SkyCoord +from astropy import units + +from astropath import localization +from astropath import bayesian + + +# Faux FRB and analysis defaults (mirroring the Profiling notebook) +FRB_RADEC = '21h44m25.255s -40d54m00.10s' +BOX_HWIDTH = 90. # arcsec; half-width of the analysis box +# step_size sweep (arcsec). ngrid = 2*box_hwidth/step_size, so with +# box_hwidth=90 these give side lengths of 360 ... 7200 pixels. +DEFAULT_STEP_SIZES = [0.5, 0.25, 0.1, 0.05, 0.025] + + +NCAND = 50 # number of candidate galaxies in the profiling scenario + + +def default_setup(ncand=NCAND): + """Build the faux-FRB profiling scenario. + + Mirrors calculations/step_size/Profiling.ipynb (circular 5" error + ellipse), but scatters ``ncand`` candidate galaxies over a range of + locations and angular sizes so the per-candidate loop in + ``px_Oi_fixedgrid`` is exercised realistically. + + Args: + ncand (int, optional): Number of candidate galaxies. + + Returns: + tuple: (localiz, cand_coords, cand_ang_size, theta_prior) + localiz (dict): eellipse localization dict. + cand_coords (SkyCoord): candidate host coordinates. + cand_ang_size (np.ndarray): candidate angular sizes, arcsec. + theta_prior (dict): offset-prior parameters. + """ + frb_coord = SkyCoord(FRB_RADEC, frame='icrs') + # Small but not tiny, circular error ellipse + eellipse = dict(a=5., b=5., theta=0.) + localiz = dict(type='eellipse', + center_coord=frb_coord, + eellipse=eellipse) + # Scatter the candidates deterministically (no RNG) over a range of + # position angles and separations from the transient. Separations + # span 0.5"-10" so some fall well inside the localization and some + # near its edge. + idx = np.arange(ncand) + pa = (idx * 360. / ncand) * units.deg # spread in PA + sep = np.linspace(0.5, 10., ncand) * units.arcsec # spread in offset + cand_coords = frb_coord.directional_offset_by(pa, sep) + # Range of angular sizes, 0.2"-3.0" + cand_ang_size = np.linspace(0.2, 3.0, ncand) # arcsec + theta_prior = dict(max=6., PDF='exp', scale=1.) + return localiz, cand_coords, cand_ang_size, theta_prior + + +def ellipse_setup(ncand=NCAND): + """High-axis-ratio ellipse scenario that exercises _Lwx_correction. + + Unlike :func:`default_setup` (circular localization, where + ``b >= phi`` so no correction fires), this uses a long thin error + ellipse (a=12.5", b=0.2", axis ratio ~60) with candidate galaxies + LARGER than ``b``. ``px_Oi_local`` therefore triggers the + ``_Lwx_correction`` for every candidate. The galaxy sizes + (1.5"-2.5") are chosen so the correction grid is ~1000x1000 cells at + the default step (0.05) -- and stays below the ~5000-cell skip + threshold across the whole step sweep. + + Args: + ncand (int, optional): Number of candidate galaxies. + + Returns: + tuple: (localiz, cand_coords, cand_ang_size, theta_prior), same + shape as :func:`default_setup`. + """ + frb_coord = SkyCoord(FRB_RADEC, frame='icrs') + # Long, thin error ellipse (large axis ratio) -> b < phi below. + eellipse = dict(a=12.5, b=0.2, theta=0.) + localiz = dict(type='eellipse', + center_coord=frb_coord, + eellipse=eellipse) + # Scatter candidates around the transient (some land off the thin + # ellipse; that is fine -- we are timing, not validating values). + idx = np.arange(ncand) + pa = (idx * 360. / ncand) * units.deg + sep = np.linspace(0.5, 8., ncand) * units.arcsec + cand_coords = frb_coord.directional_offset_by(pa, sep) + # Galaxy sizes 1.5"-2.5": all > b=0.2" (correction fires), and sized + # so the correction grid is ~1000 cells per side at step 0.05. + cand_ang_size = np.linspace(1.5, 2.5, ncand) # arcsec + theta_prior = dict(max=6., PDF='exp', scale=1.) + return localiz, cand_coords, cand_ang_size, theta_prior + + +def small_loc_setup(ncand=NCAND): + """Very small (sub-arcsec) circular localization scenario. + + A tiny circular error ellipse (a=b=0.1") with candidate galaxies + spanning 0.1"-20". For every galaxy larger than ``b`` the + ``_Lwx_correction`` fires, but because the ellipse major axis is + tiny its correction grid (~8a/h cells per side) stays small even as + the galaxy grid grows -- the opposite regime to + :func:`ellipse_setup` (large axis ratio -> large correction grid). + This stresses the deeply under-resolved case (grid spacing + ``phi*step`` can be many times ``b``). + + Args: + ncand (int, optional): Number of candidate galaxies. + + Returns: + tuple: (localiz, cand_coords, cand_ang_size, theta_prior), same + shape as :func:`default_setup`. + """ + frb_coord = SkyCoord(FRB_RADEC, frame='icrs') + # Very small, circular error ellipse + eellipse = dict(a=0.1, b=0.1, theta=0.) + localiz = dict(type='eellipse', + center_coord=frb_coord, + eellipse=eellipse) + idx = np.arange(ncand) + pa = (idx * 360. / ncand) * units.deg + sep = np.linspace(0.05, 2.0, ncand) * units.arcsec + cand_coords = frb_coord.directional_offset_by(pa, sep) + # Wide range of galaxy sizes, 0.1"-20" + cand_ang_size = np.linspace(0.1, 20., ncand) # arcsec + theta_prior = dict(max=6., PDF='exp', scale=1.) + return localiz, cand_coords, cand_ang_size, theta_prior + + +def _time_call(func, args, npix, reps=None): + """Time a single callable, returning the best wall time in seconds. + + The number of repetitions is scaled down for large grids to keep + the overall sweep fast, unless an explicit ``reps`` is given. + + Args: + func (callable): Function to time. + args (tuple): Positional arguments passed to ``func``. + npix (int): Number of grid pixels (used to pick repetitions). + reps (int, optional): Force a fixed number of repetitions. + Use reps=1 to time a single call (e.g. to *include* the + numba JIT compilation cost in the first measurement). + + Returns: + float: Best-of-reps wall-clock time, seconds. + """ + if reps is None: + # Fewer reps for big grids (they are slow and stable) + if npix > 1_000_000: + reps = 1 + elif npix > 100_000: + reps = 2 + else: + reps = 3 + best = np.inf + for _ in range(reps): + t0 = time.perf_counter() + func(*args) + best = min(best, time.perf_counter() - t0) + return best + + +def _build_grid(localiz, box_hwidth, step_size): + """Build the fixed ra/dec grid the same way px_Oi_fixedgrid does. + + Args: + localiz (dict): eellipse localization dict (needs center_coord). + box_hwidth (float): Half-width of the analysis box, arcsec. + step_size (float): Grid step size, arcsec. + + Returns: + tuple: (ra, dec, ngrid) with ra/dec numpy arrays in deg and + ngrid the number of pixels per side. + """ + ngrid = int(np.round(2 * box_hwidth / step_size)) + x = np.linspace(-box_hwidth, box_hwidth, ngrid) + xcoord, ycoord = np.meshgrid(x, x) + # Flat-sky; RA increases in x + center = localiz['center_coord'] + cos_dec = np.cos(np.radians(center.dec.deg)) + ra = center.ra.deg + xcoord / 3600. / cos_dec + dec = center.dec.deg + ycoord / 3600. + return ra, dec, ngrid + + +def run_profiling(step_sizes=None, box_hwidth=BOX_HWIDTH): + """Profile calc_LWx and px_Oi_fixedgrid over a range of grid sizes. + + Args: + step_sizes (list, optional): Grid step sizes (arcsec) to sweep. + Defaults to :data:`DEFAULT_STEP_SIZES`. + box_hwidth (float, optional): Analysis-box half-width, arcsec. + + Returns: + pandas.DataFrame: One row per step size with columns + ``step_size``, ``ngrid``, ``n_pixels``, ``calc_LWx_s``, + ``px_Oi_fixedgrid_s`` (numpy) and ``px_Oi_numba_s`` (the + numba ``use_numba=True`` path; NaN if numba is unavailable). + """ + if step_sizes is None: + step_sizes = DEFAULT_STEP_SIZES + localiz, cand_coords, cand_ang_size, theta_prior = default_setup() + + # Default correction applied to all px_Oi_fixedgrid timings here + correction = 'p_wO' + + print("Starting profiling sweep over %d step sizes, %d candidates" + % (len(step_sizes), len(cand_ang_size))) + print(" using correction=%r" % correction) + # NOTE: the numba JIT is intentionally NOT pre-warmed. Its + # compilation cost is included in the first (smallest-grid) numba + # timing below, so the reported numba time reflects a realistic + # one-off sandbox call. + + rows = [] + for step_size in step_sizes: + # Grid for the standalone calc_LWx timing + ra, dec, ngrid = _build_grid(localiz, box_hwidth, step_size) + npix = ngrid * ngrid + print(" step_size=%.4f grid=%dx%d (%d pix) ..." + % (step_size, ngrid, ngrid, npix)) + + # Time calc_LWx (localization term only) + t_lwx = _time_call(localization.calc_LWx, + (ra, dec, localiz), npix) + print(" calc_LWx: %.1f ms" % (t_lwx * 1e3)) + + # Time the full fixed-grid p(x|O_i) -- numpy path + t_pxoi = _time_call( + lambda *a: bayesian.px_Oi_fixedgrid( + box_hwidth, localiz, cand_coords, cand_ang_size, + theta_prior, step_size=step_size, correction=correction), + (), npix) + print(" px_Oi_fixedgrid (numpy): %.1f ms" % (t_pxoi * 1e3)) + + # Time the numba path (use_numba=True), if available. reps=1 so + # the first call's JIT compilation is counted in the timing. + if bayesian.HAS_NUMBA: + t_numba = _time_call( + lambda *a: bayesian.px_Oi_fixedgrid( + box_hwidth, localiz, cand_coords, cand_ang_size, + theta_prior, step_size=step_size, use_numba=True, + correction=correction), + (), npix, reps=1) + print(" px_Oi_fixedgrid (numba): %.1f ms (%.1fx)" + % (t_numba * 1e3, t_pxoi / t_numba)) + else: + t_numba = np.nan + + rows.append(dict(step_size=step_size, ngrid=ngrid, + n_pixels=npix, calc_LWx_s=t_lwx, + px_Oi_fixedgrid_s=t_pxoi, + px_Oi_numba_s=t_numba)) + + print("Profiling sweep complete.") + return pandas.DataFrame(rows) + + +def run_profiling_local(step_sizes=None): + """Profile px_Oi_local over a range of (relative) step sizes. + + ``px_Oi_local`` builds one grid per candidate, sized to the offset + prior (box_hwidth = phi*max) with spacing phi*step_size. The + per-candidate pixel count is therefore ``ngrid = 2*max/step_size`` + (independent of phi), so sweeping ``step_size`` sweeps the + per-candidate grid size. The whole multi-candidate call is timed. + + Three scenarios are timed against this SAME per-candidate galaxy + grid (the x-axis of the figure): + + * ``circular`` (:func:`default_setup`) -- ``b >= phi``, so the + ``_Lwx_correction`` never fires: pure galaxy-grid cost. + * ``ellipse`` (:func:`ellipse_setup`) -- a long thin localization + (a=12.5", b=0.2") with ``b < phi``, so the correction fires every + candidate on a ~1000x1000 grid (at the default step). + * ``small`` (:func:`small_loc_setup`) -- a tiny circular + localization (a=b=0.1") with galaxies 0.1"-20"; the correction + fires but its grid stays small (tiny major axis). Comparing the + three isolates how the correction cost scales with the + localization size. + + Args: + step_sizes (list, optional): Relative step sizes to sweep. + Defaults to :data:`DEFAULT_STEP_SIZES`. + + Returns: + pandas.DataFrame: One row per step size with columns + ``step_size``, ``ngrid`` (per candidate), ``n_pixels`` + (per candidate), ``ncand``, ``px_Oi_local_s`` (circular), + ``px_Oi_local_ellipse_s`` (ellipse + correction), + ``px_Oi_local_smallloc_s`` (small localization), and + ``corr_ngrid`` (representative ellipse correction-grid side). + """ + if step_sizes is None: + step_sizes = DEFAULT_STEP_SIZES + loc_c, cc_c, sz_c, theta_prior = default_setup() + loc_e, cc_e, sz_e, _ = ellipse_setup() + loc_s, cc_s, sz_s, _ = small_loc_setup() + ncand = len(sz_c) + max_theta = theta_prior['max'] + # Representative correction-grid size uses the ellipse major axis and + # a typical galaxy size (mirrors _Lwx_correction's window: ~8a/h). + a_e = loc_e['eellipse']['a'] + phi_mid = float(np.median(sz_e)) + + print("Starting px_Oi_local profiling (circular + ellipse + small) " + "over %d step sizes, %d candidates" % (len(step_sizes), ncand)) + + rows = [] + for step_size in step_sizes: + # Per-candidate galaxy grid size (phi cancels out of ngrid) + ngrid = int(np.round(2 * max_theta / step_size)) + npix = ngrid * ngrid + # Representative correction-grid side for the ellipse scenario. + h = 2. * (phi_mid * max_theta) / (ngrid - 1) + corr_ngrid = 2 * int(np.ceil(4. * a_e / h)) + 1 + print(" step_size=%.4f galaxy grid=%dx%d " + "ellipse corr grid~%dx%d ..." + % (step_size, ngrid, ngrid, corr_ngrid, corr_ngrid)) + + # Time all three full multi-candidate calls. Use the total + # galaxy pixel budget (ncand * npix) to choose the rep count. + t_circ = _time_call( + lambda *a: bayesian.px_Oi_local( + loc_c, cc_c, sz_c, theta_prior, step_size=step_size), + (), ncand * npix) + t_ell = _time_call( + lambda *a: bayesian.px_Oi_local( + loc_e, cc_e, sz_e, theta_prior, step_size=step_size), + (), ncand * npix) + t_small = _time_call( + lambda *a: bayesian.px_Oi_local( + loc_s, cc_s, sz_s, theta_prior, step_size=step_size), + (), ncand * npix) + print(" circular: %.1f ms ellipse(+corr): %.1f ms " + "small-loc: %.1f ms" + % (t_circ * 1e3, t_ell * 1e3, t_small * 1e3)) + + rows.append(dict(step_size=step_size, ngrid=ngrid, + n_pixels=npix, ncand=ncand, + px_Oi_local_s=t_circ, + px_Oi_local_ellipse_s=t_ell, + px_Oi_local_smallloc_s=t_small, + corr_ngrid=corr_ngrid)) + + print("px_Oi_local profiling complete.") + return pandas.DataFrame(rows) + + +def plot_local_results(df, outfile): + """Plot px_Oi_local timing vs per-candidate grid size (log-log). + + Args: + df (pandas.DataFrame): Output of :func:`run_profiling_local`. + outfile (str): Path to write the PNG figure. + + Returns: + str: The path the figure was written to. + """ + sqrt_pix = np.sqrt(df['n_pixels']) # per-candidate grid side length + fig, ax = plt.subplots(figsize=(7, 5)) + # Circular localization (a=b=5"): b >= phi for every candidate, so + # the _Lwx_correction never fires (verified: 0 invocations). + ax.plot(sqrt_pix, df['px_Oi_local_s'], 'D-', color='purple', + label='px_Oi_local (circular, b>=phi: no correction)') + # Ellipse scenario (b=0.2" < phi): the _Lwx_correction fires for + # every candidate on a ~1000x1000 grid. + if 'px_Oi_local_ellipse_s' in df: + ax.plot(sqrt_pix, df['px_Oi_local_ellipse_s'], 's-', + color='darkorange', + label='px_Oi_local (ellipse, b min_ang: + correction = 'p_wO' + step_size = eellipse['b'] / 20. + else: + correction = 'L_wx' + step_size = min_ang / 20. + idict['step_size'] = step_size + elif idict['pmode'] == 'local': + assert 'step_size' in idict, "step_size is required for local mode" + assert 'step_size_mode' in idict, "step_size_mode is required for local mode" + correction = None else: # For healpix, use default step size - step_size = 0.1 + raise ValueError("Healpix localization is not supported yet.") + # Calculate posteriors - P_Ox, P_Ux = Path.calc_posteriors('local', + if idict['pmode'] == 'local': + print(f'Calculating posteriors with local and step_size: {idict["step_size"]}') + P_Ox, P_Ux = Path.calc_posteriors( + 'local', + survey_radius=idict['ssize']*60, + step_size=idict['step_size'], + step_size_mode=idict['step_size_mode']) + elif idict['pmode'] == 'fixed': + # Memory check + if idict['ssize']*60 / step_size > 10000: + raise ValueError(f"Fixed grid would be {int(idict['ssize']*60 / step_size)} pixels. \nYour array will need >100Gb RAM. Try local or reduce your ssize if you can") + print(f'Calculating posteriors with fixed and correction: {correction}') + P_Ox, P_Ux = Path.calc_posteriors('fixed', box_hwidth=box_hwidth, - max_radius=box_hwidth, - step_size=step_size) + survey_radius=idict['ssize']*60, + step_size=step_size, + use_numba=idict['use_numba'], + correction=correction) + else: + raise ValueError(f"Unsupported posterior mode: {idict['pmode']}. " + f"Supported: 'local', 'fixed'") + + #embed(header='run.py:231') # Add photo-z columns if available in catalog photoz_columns = ['z_phot_median', 'z_phot_l68', 'z_phot_u68', @@ -217,6 +257,9 @@ def set_anly_sizes(ltype: str, lparam: dict): This helper function computes appropriate survey search radius (ssize) and maximum analysis box size (max_box) based on localization parameters. + Note: These are guidelines recommended by the PATH + developers. You should use your own judgement + Args: ltype (str): Type of localization ['eellipse', 'healpix'] lparam (dict): Parameters for localization @@ -265,6 +308,10 @@ def build_idict(ra: float, dec: float, scale: float = 0.5, theta_PDF: str = 'exp', theta_max: float = 6.0, + use_numba: bool = False, + pmode: str = 'local', + step_size_mode: str = 'relative', + step_size: float = 0.05, survey: str = None, ssize: float = None, max_box: float = None): @@ -288,6 +335,7 @@ def build_idict(ra: float, dec: float, survey (str, optional): Survey name for automatic catalog query. Supported: 'Pan-STARRS', 'DECaL'. If None, catalog must be provided to run_on_dict(). + use_numba (bool): Use numba for calculations. Default False. ssize (float): Survey search radius in arcmin. If None, auto-computed. max_box (float): Maximum analysis box in arcsec. If None, auto-computed. @@ -322,11 +370,15 @@ def build_idict(ra: float, dec: float, idict = { 'ra': ra, 'dec': dec, - 'ssize': ssize, + 'ssize': ssize, # arcmin 'ltype': ltype, 'lparam': lparam, + 'use_numba': use_numba, + 'pmode': pmode, + 'step_size_mode': step_size_mode, + 'step_size': step_size, 'priors': priors, - 'max_box': max_box, + 'max_box': max_box, # arcsec } return idict diff --git a/astropath/tests/test_bayesian.py b/astropath/tests/test_bayesian.py index 708ab3d..4e030f3 100644 --- a/astropath/tests/test_bayesian.py +++ b/astropath/tests/test_bayesian.py @@ -148,9 +148,9 @@ def test_PU(): p_xU = bayesian.px_U(box_radius) # p(x) p_x = np.sum(candidates.P_O * candidates.p_xO) + p_xU * cand_prior['P_U'] - assert np.isclose(p_x, 0.010006174202053927) + assert np.isclose(p_x, 0.010013764189863593) # P(U|x) P_Ux = cand_prior['P_U'] * p_xU / p_x - assert np.isclose(P_Ux, 0.0027760637799086035) + assert np.isclose(P_Ux, 0.003531915118126432) diff --git a/astropath/tests/test_path.py b/astropath/tests/test_path.py index fb4cb87..ee84d80 100644 --- a/astropath/tests/test_path.py +++ b/astropath/tests/test_path.py @@ -91,5 +91,8 @@ def test_gw(): P_Ox, P_Ux = Path.calc_posteriors('local', box_hwidth=30.) # Calculate p(x|O) - assert np.isclose(np.max(Path.p_xOi), 0.0002810125426532622) + # Reference value at the current default step_size=0.05 (the old + # 0.0002810125426532622 was tied to the prior default step_size=0.1; + # the finer 0.05 grid is more accurate and converges toward ~2.853e-4). + assert np.isclose(np.max(Path.p_xOi), 0.0002833731343742291) assert np.isclose(P_Ox.max(), 0.9999929552509278) \ No newline at end of file diff --git a/astropath/tests/test_run.py b/astropath/tests/test_run.py index 4de8351..7cc2215 100644 --- a/astropath/tests/test_run.py +++ b/astropath/tests/test_run.py @@ -43,7 +43,11 @@ def test_run_on_dict_eellipse(): PU=0., scale=1., theta_PDF='exp', - theta_max=6. + theta_max=6., + # Use the local method: with this tiny a=b=0.1" localization the + # fixed grid would be ~15700x15700 (~20 GB peak) and OOM-kill the + # CI runner. The local method gives the same posterior to ~2e-7. + pmode='local', ) # Run PATH @@ -87,6 +91,9 @@ def test_run_on_dict_with_PU(): lparam={'a': 0.1, 'b': 0.1, 'theta': 0.}, PU=0.1, # Non-zero unseen prior scale=1., + # Local method (see test_run_on_dict_eellipse): avoids the huge + # fixed grid that OOM-kills CI for this tiny localization. + pmode='local', ) # Run PATH diff --git a/astropath/tests/test_speed_up.py b/astropath/tests/test_speed_up.py new file mode 100644 index 0000000..05d39cc --- /dev/null +++ b/astropath/tests/test_speed_up.py @@ -0,0 +1,414 @@ +""" Test the numpy speed-up of localization.calc_LWx (eellipse type). + +The eellipse branch of localization.calc_LWx was re-implemented in pure +numpy (replacing astropy SkyCoord / separation / position_angle). These +tests: + + 1. Verify the new numpy code reproduces the original astropy code to + within tight numerical tolerances. + 2. Time both implementations and report the speed-up, including a large + 7200x7200 pixel grid. + +See prompts/speed_up.md for the analysis behind the change. +""" + +import time + +import numpy as np + +from astropy.coordinates import SkyCoord +from astropy import units + +from astropath import localization +from astropath import bayesian + +import pytest + + +def _calc_LWx_eellipse_astropy(ra, dec, localiz): + """Original (astropy-based) eellipse implementation of calc_LWx. + + Frozen here as the reference for regression/speed comparison. This + is a verbatim copy of the eellipse branch of localization.calc_LWx + as it existed before the numpy rewrite. + + Args: + ra (np.ndarray): RA grid (ICRS), deg. + dec (np.ndarray): Dec grid (ICRS), deg. + localiz (dict): Localization dict (eellipse type). + + Returns: + np.ndarray: L(w-x) grid, same shape as ra/dec. + """ + eellipse = localiz['eellipse'] # convenience + pa_ee = eellipse['theta'] # PA of error ellipse on the sky; deg + # Rotation to place the semi-major axis "a" along the x-axis + dtheta = 90. - pa_ee + # + coord = SkyCoord(ra=ra, dec=dec, unit='deg') + coord.equinox = localiz['center_coord'].equinox + # Rotate to the transient frame + sep_box = localiz['center_coord'].separation(coord).to('arcsec') + pa_box = localiz['center_coord'].position_angle(coord).to('deg') + new_pa_box = pa_box + dtheta * units.deg + # x, y of the box in transient frame with x along major axis + x_box = -sep_box.value * np.sin(new_pa_box).value + y_box = sep_box.value * np.cos(new_pa_box).value + # Calculate + L_wx = np.exp(-x_box ** 2 / (2 * eellipse['a'] ** 2)) * np.exp( + -y_box ** 2 / (2 * eellipse['b'] ** 2)) / ( + 2 * np.pi * eellipse['a'] * eellipse['b']) + return L_wx + + +def _build_grid(cent_ra, cent_dec, box_hwidth, ngrid): + """Build an ra/dec grid around a center (flat-sky), as the callers do. + + Args: + cent_ra (float): Central RA, deg. + cent_dec (float): Central Dec, deg. + box_hwidth (float): Half-width of the grid, arcsec. + ngrid (int): Number of pixels per side. + + Returns: + tuple: (ra, dec) numpy arrays of shape (ngrid, ngrid), deg. + """ + x = np.linspace(-box_hwidth, box_hwidth, ngrid) + xcoord, ycoord = np.meshgrid(x, x) + # RA increases in x; flat-sky scaling by cos(dec) + ra = cent_ra + xcoord / 3600. / np.cos(np.radians(cent_dec)) + dec = cent_dec + ycoord / 3600. + return ra, dec + + +def _eellipse_localiz(cent_ra, cent_dec, a=1.0, b=0.5, theta=45.): + """Construct an eellipse localization dict for testing. + + Args: + cent_ra (float): Central RA, deg. + cent_dec (float): Central Dec, deg. + a (float): Semi-major axis, arcsec. + b (float): Semi-minor axis, arcsec. + theta (float): Position angle of the ellipse, deg (E of N). + + Returns: + dict: Localization dict (eellipse type). + """ + center = SkyCoord(ra=cent_ra, dec=cent_dec, unit='deg') + return dict(type='eellipse', + center_coord=center, + eellipse=dict(a=a, b=b, theta=theta)) + + +def test_eellipse_matches_astropy(): + """numpy calc_LWx must match the frozen astropy implementation.""" + cent_ra, cent_dec = 120.0, 32.0 + localiz = _eellipse_localiz(cent_ra, cent_dec) + # Modest grid; box_hwidth=10", step_size=0.1" -> 200x200 + ra, dec = _build_grid(cent_ra, cent_dec, box_hwidth=10., ngrid=200) + + L_new = localization.calc_LWx(ra, dec, localiz) + L_ref = _calc_LWx_eellipse_astropy(ra, dec, localiz) + + # Tight tolerance: the two should agree to roundoff + assert np.allclose(L_new, L_ref, rtol=1e-8, atol=1e-12) + # Sanity: L_wx peaks at the center pixel region and is finite + assert np.all(np.isfinite(L_new)) + + +def test_eellipse_matches_astropy_offcenter(): + """Match also at a southern, high-PA case to exercise the geometry.""" + cent_ra, cent_dec = 263.667, -50.768 + localiz = _eellipse_localiz(cent_ra, cent_dec, a=2.0, b=0.7, theta=110.) + ra, dec = _build_grid(cent_ra, cent_dec, box_hwidth=15., ngrid=150) + + L_new = localization.calc_LWx(ra, dec, localiz) + L_ref = _calc_LWx_eellipse_astropy(ra, dec, localiz) + + assert np.allclose(L_new, L_ref, rtol=1e-8, atol=1e-12) + + +def _time_call(func, ra, dec, localiz, reps=3): + """Return the best-of-reps wall time (s) for func(ra, dec, localiz). + + Args: + func (callable): Implementation to time. + ra, dec (np.ndarray): Grid coords. + localiz (dict): Localization dict. + reps (int): Number of repetitions; the minimum is returned. + + Returns: + float: Best wall-clock time in seconds. + """ + best = np.inf + for _ in range(reps): + t0 = time.perf_counter() + func(ra, dec, localiz) + best = min(best, time.perf_counter() - t0) + return best + + +@pytest.mark.parametrize("ngrid", [200, 1000, 7200]) +def test_eellipse_speed_up(ngrid, capsys): + """Time numpy vs astropy and report the speed-up. + + Includes the requested 7200x7200 pixel grid. Also re-checks + correctness on each grid (subsampled for the largest grid to keep + memory/time reasonable). + """ + cent_ra, cent_dec = 120.0, 32.0 + localiz = _eellipse_localiz(cent_ra, cent_dec) + # Keep angular scale fixed-ish; box grows with ngrid + box_hwidth = 0.05 * ngrid # arcsec (0.1"/pix) + ra, dec = _build_grid(cent_ra, cent_dec, box_hwidth, ngrid) + + t_np = _time_call(localization.calc_LWx, ra, dec, localiz) + t_ap = _time_call(_calc_LWx_eellipse_astropy, ra, dec, localiz) + + # Correctness check (single eval) + L_new = localization.calc_LWx(ra, dec, localiz) + L_ref = _calc_LWx_eellipse_astropy(ra, dec, localiz) + assert np.allclose(L_new, L_ref, rtol=1e-8, atol=1e-12) + + speedup = t_ap / t_np if t_np > 0 else np.inf + # Report (use -s to see this output) + with capsys.disabled(): + print( + "\n grid %5dx%-5d (%9d pts): " + "astropy %8.2f ms numpy %8.2f ms speed-up %5.1fx" + % (ngrid, ngrid, ngrid * ngrid, + t_ap * 1e3, t_np * 1e3, speedup)) + + # The numpy path should never be slower than astropy + assert t_np <= t_ap + + +# --------------------------------------------------------------------------- +# px_Oi_fixedgrid: replaced per-candidate / center astropy access with numpy +# (pre-extracted arrays). Reference below freezes the original astropy +# implementation for regression + speed comparison. +# --------------------------------------------------------------------------- + + +def _px_Oi_fixedgrid_astropy(box_hwidth, localiz, cand_coords, + cand_ang_size, theta_prior, step_size=0.1): + """Original (astropy-based) px_Oi_fixedgrid implementation. + + Verbatim copy of the loop/grid logic as it existed before the numpy + rewrite (iterates the SkyCoord array, reads .ra/.dec per candidate, + sets equinox). Kept here as the reference for the tests. Returns + only the p(x|O_i) array (the only output the tests need). + + Args: + box_hwidth (float): Half-width of the analysis box, arcsec. + localiz (dict): Localization dict (must have center_coord). + cand_coords (SkyCoord): Candidate host coordinates. + cand_ang_size (np.ndarray): Candidate angular sizes, arcsec. + theta_prior (dict): Offset-prior parameters. + step_size (float): Grid step size, arcsec. + + Returns: + np.ndarray: p(x|O_i) for each candidate. + """ + # Set Equinox (for spherical offsets) + localiz['center_coord'].equinox = cand_coords[0].equinox + # Build the fixed grid around the transient + ngrid = int(np.round(2 * box_hwidth / step_size)) + x = np.linspace(-box_hwidth, box_hwidth, ngrid) + xcoord, ycoord = np.meshgrid(x, x) + grid_spacing_arcsec = x[1] - x[0] + # L(w-x); RA increases in x (flat-sky) + ra = localiz['center_coord'].ra.deg + \ + xcoord / 3600. / np.cos(localiz['center_coord'].dec).value + dec = localiz['center_coord'].dec.deg + ycoord / 3600. + L_wx = localization.calc_LWx(ra, dec, localiz) + p_xOis = [] + for icand, cand_coord in enumerate(cand_coords): + # Offsets from the transient (flat sky) + theta = 3600 * np.sqrt(np.cos(cand_coord.dec).value**2 * ( + ra - cand_coord.ra.deg)**2 + + (dec - cand_coord.dec.deg)**2) # arcsec + p_wOi = bayesian.pw_Oi(theta, cand_ang_size[icand], theta_prior) + grid_p = L_wx * p_wOi + p_xOis.append(np.sum(grid_p) * grid_spacing_arcsec**2) + return np.array(p_xOis) + + +def _make_candidates(cent_ra, cent_dec, ncand=10, spread=8.): + """Build a SkyCoord of candidates scattered around a center. + + Args: + cent_ra (float): Central RA, deg. + cent_dec (float): Central Dec, deg. + ncand (int): Number of candidates. + spread (float): Half-spread of the scatter, arcsec. + + Returns: + tuple: (cand_coords SkyCoord, cand_ang_size ndarray arcsec). + """ + # Deterministic offsets (no RNG) spanning +/- spread arcsec + off = np.linspace(-spread, spread, ncand) + cand_ra = cent_ra + off / 3600. / np.cos(np.radians(cent_dec)) + cand_dec = cent_dec + off[::-1] / 3600. + cand_coords = SkyCoord(ra=cand_ra, dec=cand_dec, unit='deg') + # Angular sizes 0.5-2.0 arcsec + cand_ang_size = np.linspace(0.5, 2.0, ncand) + return cand_coords, cand_ang_size + + +def test_px_Oi_fixedgrid_matches_astropy(): + """numpy px_Oi_fixedgrid must match the frozen astropy version.""" + cent_ra, cent_dec = 120.0, 32.0 + localiz = _eellipse_localiz(cent_ra, cent_dec, a=1.0, b=0.6, theta=30.) + cand_coords, cand_ang_size = _make_candidates(cent_ra, cent_dec) + theta_prior = dict(PDF='exp', max=6., scale=0.5) + + p_new = bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior) + p_ref = _px_Oi_fixedgrid_astropy( + 10., localiz, cand_coords, cand_ang_size, theta_prior) + + # Same math, only coordinate extraction changed -> agree to roundoff + assert np.allclose(p_new, p_ref, rtol=1e-10, atol=1e-15) + + +def test_px_Oi_fixedgrid_speed_up(capsys): + """Time numpy vs astropy px_Oi_fixedgrid and report the speed-up.""" + cent_ra, cent_dec = 120.0, 32.0 + localiz = _eellipse_localiz(cent_ra, cent_dec, a=1.0, b=0.6, theta=30.) + # Many candidates: the per-candidate astropy overhead is the target + cand_coords, cand_ang_size = _make_candidates( + cent_ra, cent_dec, ncand=50) + theta_prior = dict(PDF='exp', max=6., scale=0.5) + + def _np(*_): + return bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior) + + def _ap(*_): + return _px_Oi_fixedgrid_astropy( + 10., localiz, cand_coords, cand_ang_size, theta_prior) + + # _time_call signature is (func, ra, dec, localiz); pass dummies + t_np = _time_call(_np, None, None, None) + t_ap = _time_call(_ap, None, None, None) + + assert np.allclose(_np(), _ap(), rtol=1e-10, atol=1e-15) + + speedup = t_ap / t_np if t_np > 0 else np.inf + with capsys.disabled(): + print( + "\n px_Oi_fixedgrid (50 cand, 200x200): " + "astropy %8.2f ms numpy %8.2f ms speed-up %5.1fx" + % (t_ap * 1e3, t_np * 1e3, speedup)) + + # numpy path should not be slower + assert t_np <= t_ap + + +# --------------------------------------------------------------------------- +# Optional numba kernel (use_numba=True) for px_Oi_fixedgrid. +# --------------------------------------------------------------------------- + +# Skip the numba tests entirely if numba is not installed +numba_required = pytest.mark.skipif( + not bayesian.HAS_NUMBA, reason='numba not installed') + + +@numba_required +@pytest.mark.parametrize("pdf", ['exp', 'core', 'uniform']) +def test_px_Oi_fixedgrid_numba_matches_numpy(pdf): + """use_numba=True must match the numpy path for every PDF.""" + cent_ra, cent_dec = 120.0, 32.0 + localiz = _eellipse_localiz(cent_ra, cent_dec, a=1.0, b=0.6, theta=30.) + cand_coords, cand_ang_size = _make_candidates(cent_ra, cent_dec) + theta_prior = dict(PDF=pdf, max=6., scale=0.5) + + p_np = bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior, + use_numba=False) + p_nb = bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior, + use_numba=True) + + # Same math, just fused in the kernel -> agree to roundoff + assert np.allclose(p_np, p_nb, rtol=1e-10, atol=1e-15) + + +@numba_required +@pytest.mark.parametrize("pdf", ['exp', 'core', 'uniform']) +@pytest.mark.parametrize("correction", ['p_wO', 'L_wx']) +def test_px_Oi_fixedgrid_numba_matches_numpy_correction(pdf, correction): + """numba must match numpy with the optional correction factor too.""" + cent_ra, cent_dec = 120.0, 32.0 + localiz = _eellipse_localiz(cent_ra, cent_dec, a=1.0, b=0.6, theta=30.) + cand_coords, cand_ang_size = _make_candidates(cent_ra, cent_dec) + theta_prior = dict(PDF=pdf, max=6., scale=0.5) + + p_np = bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior, + use_numba=False, correction=correction) + p_nb = bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior, + use_numba=True, correction=correction) + + assert np.allclose(p_np, p_nb, rtol=1e-10, atol=1e-15) + + +def test_px_Oi_fixedgrid_numba_fallback_without_numba(monkeypatch): + """use_numba=True falls back to numpy (with a warning) if numba is + unavailable, and still returns the correct result.""" + cent_ra, cent_dec = 120.0, 32.0 + localiz = _eellipse_localiz(cent_ra, cent_dec, a=1.0, b=0.6, theta=30.) + cand_coords, cand_ang_size = _make_candidates(cent_ra, cent_dec) + theta_prior = dict(PDF='exp', max=6., scale=0.5) + + # Pretend numba is absent regardless of the environment + monkeypatch.setattr(bayesian, 'HAS_NUMBA', False) + + p_ref = bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior, + use_numba=False) + with pytest.warns(UserWarning): + p_fb = bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior, + use_numba=True) + assert np.allclose(p_ref, p_fb, rtol=1e-10, atol=1e-15) + + +@numba_required +def test_px_Oi_fixedgrid_numba_speed_up(capsys): + """Time numba vs numpy px_Oi_fixedgrid and report the speed-up. + + The first numba call pays JIT-compile time, so the kernel is warmed + up once before timing. + """ + cent_ra, cent_dec = 120.0, 32.0 + localiz = _eellipse_localiz(cent_ra, cent_dec, a=1.0, b=0.6, theta=30.) + cand_coords, cand_ang_size = _make_candidates( + cent_ra, cent_dec, ncand=50) + theta_prior = dict(PDF='exp', max=6., scale=0.5) + + def _np(*_): + return bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior, + use_numba=False) + + def _nb(*_): + return bayesian.px_Oi_fixedgrid( + 10., localiz, cand_coords, cand_ang_size, theta_prior, + use_numba=True) + + # Warm up the JIT (compile) before timing + p_nb = _nb() + assert np.allclose(_np(), p_nb, rtol=1e-10, atol=1e-15) + + t_np = _time_call(_np, None, None, None) + t_nb = _time_call(_nb, None, None, None) + + speedup = t_np / t_nb if t_nb > 0 else np.inf + with capsys.disabled(): + print( + "\n px_Oi_fixedgrid (50 cand, 200x200): " + "numpy %8.2f ms numba %8.2f ms speed-up %5.1fx" + % (t_np * 1e3, t_nb * 1e3, speedup)) diff --git a/astropath/tests/tests_local.py b/astropath/tests/tests_local.py new file mode 100644 index 0000000..9894bfb --- /dev/null +++ b/astropath/tests/tests_local.py @@ -0,0 +1,324 @@ +""" Accuracy tests for bayesian.px_Oi_local. + +These tests establish a correctness baseline for ``px_Oi_local`` BEFORE +we start optimizing it (numpy rewrite, then numba; see +``prompts/speed_up_local.md``). Both ``px_Oi_local`` and +``px_Oi_fixedgrid`` evaluate the same integral + + p(x|O_i) = integral over w of L(w-x) * p(w|O_i) dw + +just discretized on different grids: ``px_Oi_local`` builds a grid +centered on the galaxy and sized to the offset-prior support +(phi*max), while ``px_Oi_fixedgrid`` builds a grid centered on the +transient. Run with a sufficiently fine step the fixed-grid result is +effectively the truth, so we use it as the reference and check that the +(coarser) local method reproduces it. + +Empirically the local method's RELATIVE error is ~0.17*step_size (first +order in the grid spacing): step_size=0.1 -> ~1.7%, 0.05 -> ~0.8%, +0.02 -> ~0.33%. The tests below run the local method at step_size=0.02 +and require agreement to better than 1% with the fine fixed grid. + +The cases requested in the prompt cover the relevant size regimes: + * large galaxy (10") with a small localization (1") + * large galaxy (10") with a large localization (10") + * small galaxy (1") with a small localization (1") + * small galaxy (1") with a large localization (10") + * small galaxy (0.5") with an ellipse localization (a=10", b=0.2") +""" + +import numpy as np + +from astropy.coordinates import SkyCoord +from astropy import units + +from astropath import bayesian + +import pytest + +# Offset prior shared by every comparison. Exponential PDF with a hard +# cutoff at max*phi (matches the priors used elsewhere in the package). +THETA_PRIOR = dict(max=6., PDF='exp', scale=0.5) + +# Reference transient = localization center (mid-declination ICRS so the +# cos(dec) flat-sky scaling is exercised but not degenerate). +CENT_RA, CENT_DEC = 120.0, 32.0 + +# Local-method grid step used for the matching tests. At this (relative) +# step the local error is ~0.33%, comfortably inside RTOL below. +LOCAL_STEP = 0.02 +RTOL = 1.0e-2 + +# Comparison cases. Each tuple is: +# (label, phi_gal, a, b, pa_ee, gal_offset, gal_pa) +# phi_gal : galaxy angular size (arcsec) +# a, b : localization ellipse semi-axes (arcsec); a==b -> circle +# pa_ee : position angle of the localization ellipse (deg) +# gal_offset : galaxy offset from the transient center (arcsec) +# gal_pa : position angle of that offset (deg E of N) +CASES = [ + ("large_gal10_small_loc1", 10., 1., 1., 0., 1.0, 0.), + ("large_gal10_large_loc10", 10., 10., 10., 0., 3.0, 0.), + ("small_gal1_small_loc1", 1., 1., 1., 0., 1.0, 0.), + ("small_gal1_large_loc10", 1., 10., 10., 0., 3.0, 0.), + ("small_gal0p5_ellipse", 0.5, 10., 0.2, 0., 2.0, 90.), +] + + +def _center(): + """Return the transient/localization center coordinate. + + Returns: + SkyCoord: ICRS center coordinate (CENT_RA, CENT_DEC). + """ + return SkyCoord(ra=CENT_RA, dec=CENT_DEC, unit='deg') + + +def _eellipse_localiz(a, b, pa_ee): + """Build an eellipse localization dict centered on the transient. + + Args: + a (float): Semi-major axis of the error ellipse, arcsec. + b (float): Semi-minor axis of the error ellipse, arcsec. + pa_ee (float): Position angle of the ellipse, deg (E of N). + + Returns: + dict: Localization dict (eellipse type) with center_coord set. + """ + return dict(type='eellipse', + center_coord=_center(), + eellipse=dict(a=a, b=b, theta=pa_ee)) + + +def _galaxy(offset, gal_pa): + """Build a single-candidate SkyCoord offset from the transient. + + Args: + offset (float): Angular offset from the center, arcsec. + gal_pa (float): Position angle of the offset, deg (E of N). + + Returns: + SkyCoord: Length-1 SkyCoord array for the candidate galaxy. + """ + gal = _center().directional_offset_by( + gal_pa * units.deg, offset * units.arcsec) + # Re-wrap as a length-1 array so it iterates like the real input. + return SkyCoord([gal.ra.deg], [gal.dec.deg], unit='deg') + + +def _fine_fixedgrid_reference(phi, a, b, pa_ee, offset, gal_pa): + """Accurate p(x|O_i) from px_Oi_fixedgrid on a fine, large-enough grid. + + The integrand L(w-x)*p(w|O_i) is non-zero only within phi*max of the + galaxy (the offset prior's hard cutoff), so a box reaching + ``offset + phi*max`` from the transient (plus a small margin) fully + contains it. The step resolves the smallest relevant scale + (the smaller of the ellipse minor axis and the galaxy size), making + the fixed-grid result effectively exact for our purposes. + + Args: + phi (float): Galaxy angular size, arcsec. + a (float): Localization semi-major axis, arcsec. + b (float): Localization semi-minor axis, arcsec. + pa_ee (float): Localization ellipse PA, deg. + offset (float): Galaxy offset from the transient, arcsec. + gal_pa (float): PA of the galaxy offset, deg. + + Returns: + float: Reference p(x|O_i) for the single candidate. + """ + localiz = _eellipse_localiz(a, b, pa_ee) + cand = _galaxy(offset, gal_pa) + cand_ang_size = np.array([phi]) + # Box must cover the offset-prior support around the galaxy. + box_hwidth = offset + phi * THETA_PRIOR['max'] + 3.0 # arcsec + # Resolve the smallest scale; floor keeps grids tractable. + fine_step = max(min(b, phi) / 30., 0.005) # arcsec + p_ref = bayesian.px_Oi_fixedgrid( + box_hwidth, localiz, cand, cand_ang_size, + THETA_PRIOR, step_size=fine_step) + return p_ref[0] + + +@pytest.mark.parametrize( + "label,phi,a,b,pa_ee,offset,gal_pa", CASES, + ids=[c[0] for c in CASES]) +def test_local_matches_fine_fixedgrid( + label, phi, a, b, pa_ee, offset, gal_pa, capsys): + """px_Oi_local must match the fine fixed-grid reference (<1%). + + Runs the local method at step_size=LOCAL_STEP and compares to the + accurate fixed-grid value for each size regime. + """ + localiz = _eellipse_localiz(a, b, pa_ee) + cand = _galaxy(offset, gal_pa) + cand_ang_size = np.array([phi]) + + p_ref = _fine_fixedgrid_reference( + phi, a, b, pa_ee, offset, gal_pa) + p_loc = bayesian.px_Oi_local( + localiz, cand, cand_ang_size, THETA_PRIOR, + step_size=LOCAL_STEP)[0] + + rel = (p_loc - p_ref) / p_ref + with capsys.disabled(): + print("\n %-24s local=%11.5e fixed(fine)=%11.5e " + "reldiff=%+.3e" % (label, p_loc, p_ref, rel)) + + assert np.isfinite(p_loc) and p_loc > 0 + assert np.isclose(p_loc, p_ref, rtol=RTOL, atol=0.0) + + +# Cases where the localization minor axis is smaller than the galaxy +# (b < phi) -- these trigger the localization-centered L_wx correction. +CORR_CASES = [c for c in CASES if c[3] < c[1]] # b (idx 3) < phi (idx 1) + + +@pytest.mark.parametrize( + "label,phi,a,b,pa_ee,offset,gal_pa", CORR_CASES, + ids=[c[0] for c in CORR_CASES]) +@pytest.mark.parametrize("coarse_step", [0.05, 0.1]) +def test_local_correction_coarse_step( + label, phi, a, b, pa_ee, offset, gal_pa, coarse_step, capsys): + """When b < phi, the _Lwx_correction keeps px_Oi_local accurate even + at coarse (galaxy-relative) step sizes. + + The fast aligned-grid correction divides the under-resolved raw sum + by the discrete "total L_wx"; the aliasing cancels, recovering ~0.1- + 0.2% accuracy where the UNcorrected raw sum is biased by ~1-2% (the + O(step) error). Tolerance is well below that raw bias but looser + than the old fine-grid helper (the new method is ~1%-class by + design). + """ + localiz = _eellipse_localiz(a, b, pa_ee) + cand = _galaxy(offset, gal_pa) + cand_ang_size = np.array([phi]) + + p_ref = _fine_fixedgrid_reference( + phi, a, b, pa_ee, offset, gal_pa) + p_loc = bayesian.px_Oi_local( + localiz, cand, cand_ang_size, THETA_PRIOR, + step_size=coarse_step)[0] + + rel = (p_loc - p_ref) / p_ref + with capsys.disabled(): + print("\n %-24s step=%.2f local=%11.5e fixed(fine)=%11.5e " + "reldiff=%+.3e" % (label, coarse_step, p_loc, p_ref, rel)) + + # Much tighter than the generic RTOL: the correction removes the + # bulk of the step-size bias for these cases. + assert np.isclose(p_loc, p_ref, rtol=5.0e-3, atol=0.0) + + +# Very small (sub-arcsec) circular localizations -- the deeply +# under-resolved regime (grid spacing phi*step >> b). phi is kept <= 1" +# so the fine fixed-grid reference stays well under 5000 cells per side. +SMALL_LOC_CASES = [ + ("small_loc_gal0p3", 0.3, 0.1, 0.1, 0., 0.3, 0.), + ("small_loc_gal0p6", 0.6, 0.1, 0.1, 0., 0.3, 0.), + ("small_loc_gal1", 1.0, 0.1, 0.1, 0., 0.3, 0.), +] + + +@pytest.mark.parametrize( + "label,phi,a,b,pa_ee,offset,gal_pa", SMALL_LOC_CASES, + ids=[c[0] for c in SMALL_LOC_CASES]) +def test_local_small_localization( + label, phi, a, b, pa_ee, offset, gal_pa, capsys): + """px_Oi_local stays accurate for a very small localization (0.1"). + + Here ``b < phi`` so the _Lwx_correction fires, and the galaxy grid + badly under-resolves the 0.1" localization (spacing phi*step can be + many times b). The correction must still recover the fine fixed-grid + value. Run at the default step (0.05). + """ + localiz = _eellipse_localiz(a, b, pa_ee) + cand = _galaxy(offset, gal_pa) + cand_ang_size = np.array([phi]) + + p_ref = _fine_fixedgrid_reference( + phi, a, b, pa_ee, offset, gal_pa) + p_loc = bayesian.px_Oi_local( + localiz, cand, cand_ang_size, THETA_PRIOR, step_size=0.05)[0] + + rel = (p_loc - p_ref) / p_ref + with capsys.disabled(): + print("\n %-18s local=%11.5e fixed(fine)=%11.5e " + "reldiff=%+.3e" % (label, p_loc, p_ref, rel)) + + assert np.isfinite(p_loc) and p_loc > 0 + assert np.isclose(p_loc, p_ref, rtol=RTOL, atol=0.0) + + +def test_local_multi_candidate_matches_fixedgrid(capsys): + """All cases at once: px_Oi_local on a multi-candidate input. + + Drives the candidate loop with every regime in a single call (a + useful guard for future vectorization/numba work) and checks each + against its fine fixed-grid reference. + """ + # Build one SkyCoord holding all candidate galaxies + their sizes. + ras, decs, sizes, refs = [], [], [], [] + for label, phi, a, b, pa_ee, offset, gal_pa in CASES: + gal = _galaxy(offset, gal_pa) + ras.append(gal.ra.deg[0]) + decs.append(gal.dec.deg[0]) + sizes.append(phi) + refs.append(_fine_fixedgrid_reference( + phi, a, b, pa_ee, offset, gal_pa)) + cand = SkyCoord(ra=ras, dec=decs, unit='deg') + cand_ang_size = np.array(sizes) + refs = np.array(refs) + + # The localization differs per case, so px_Oi_local cannot be run + # once for all candidates; we drive it per candidate but through the + # same array-style call signature used in production. + p_loc = np.array([ + bayesian.px_Oi_local( + _eellipse_localiz(a, b, pa_ee), + SkyCoord([ra], [dec], unit='deg'), + np.array([phi]), THETA_PRIOR, step_size=LOCAL_STEP)[0] + for (label, phi, a, b, pa_ee, offset, gal_pa), ra, dec + in zip(CASES, ras, decs)]) + + rel = (p_loc - refs) / refs + with capsys.disabled(): + print("\n multi-candidate max |reldiff| = %.3e" % + np.max(np.abs(rel))) + + assert np.all(np.isfinite(p_loc)) and np.all(p_loc > 0) + assert np.allclose(p_loc, refs, rtol=RTOL, atol=0.0) + + +def test_local_convergence_to_fixedgrid(): + """The local error must shrink ~linearly as step_size decreases. + + Uses the small-galaxy/small-localization case (cheap, well behaved) + and confirms the relative error vs the fine fixed grid both (a) + decreases monotonically and (b) roughly halves when the step is + halved -- i.e. first-order convergence to the same integral. + """ + phi, a, b, pa_ee, offset, gal_pa = 1., 1., 1., 0., 1.0, 0. + localiz = _eellipse_localiz(a, b, pa_ee) + cand = _galaxy(offset, gal_pa) + cand_ang_size = np.array([phi]) + + p_ref = _fine_fixedgrid_reference( + phi, a, b, pa_ee, offset, gal_pa) + + steps = [0.1, 0.05, 0.025] + rel_err = [] + for ss in steps: + p_loc = bayesian.px_Oi_local( + localiz, cand, cand_ang_size, THETA_PRIOR, + step_size=ss)[0] + rel_err.append(abs(p_loc - p_ref) / p_ref) + rel_err = np.array(rel_err) + + # Monotonic decrease with finer steps. + assert np.all(np.diff(rel_err) < 0) + # First-order: halving the step should roughly halve the error. + # Allow a generous band around the ideal factor of 2. + for i in range(len(steps) - 1): + ratio = rel_err[i] / rel_err[i + 1] + assert 1.6 < ratio < 2.4 diff --git a/calculations/step_size/Profiling.ipynb b/calculations/step_size/Profiling.ipynb new file mode 100644 index 0000000..cd3ee98 --- /dev/null +++ b/calculations/step_size/Profiling.ipynb @@ -0,0 +1,642 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d7d37368-c3bf-409a-baed-92aa8ae7e4da", + "metadata": {}, + "source": [ + "# Profiling for PATH" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "437a70b4-3383-4150-bd32-5cf699eaf30b", + "metadata": {}, + "outputs": [], + "source": [ + "# imports\n", + "from importlib import reload\n", + "import os\n", + "from importlib.resources import files as resource_files\n", + "\n", + "import numpy as np\n", + "\n", + "import pandas\n", + "\n", + "from astropy.coordinates import SkyCoord\n", + "from astropy.coordinates import offset_by\n", + "from astropy import units\n", + "#from astropy.io import fits\n", + "\n", + "from astropath import path\n", + "from astropath import localization\n", + "from astropath import bayesian" + ] + }, + { + "cell_type": "markdown", + "id": "fc737260-332c-4826-9175-43651e1b94fe", + "metadata": {}, + "source": [ + "# Convenience class" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f3eb095d-fe29-423a-915b-da42129781e3", + "metadata": {}, + "outputs": [], + "source": [ + "Path = path.PATH()" + ] + }, + { + "cell_type": "markdown", + "id": "b33b8175-ba4d-498f-a771-d3ab84506125", + "metadata": {}, + "source": [ + "# Faux FRB" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "bca3fbb6-6452-4d56-b6ab-8a95242a7899", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## FRB Coord\n", + "frb_coord = SkyCoord('21h44m25.255s -40d54m00.10s', frame='icrs')\n", + "frb_coord" + ] + }, + { + "cell_type": "markdown", + "id": "6bcba1af-5912-4e0f-ac65-d34fe7ad13dc", + "metadata": {}, + "source": [ + "# Prior" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e6fb9982-fc3d-435c-a2ed-1852c72bac51", + "metadata": {}, + "outputs": [], + "source": [ + "theta_prior = dict(max=6., PDF='exp', scale=1.)" + ] + }, + { + "cell_type": "markdown", + "id": "e104c1a9-2030-4280-bdf4-29a08eacca6e", + "metadata": {}, + "source": [ + "# Localization" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "73d77df6-8227-4041-914a-a8128291ac9a", + "metadata": {}, + "outputs": [], + "source": [ + "# Small, but not tiny\n", + "eellipse = dict(a=5, b=5, theta=0.)" + ] + }, + { + "cell_type": "markdown", + "id": "a961b5e7-32b5-4c87-9461-4def50dbc1d6", + "metadata": {}, + "source": [ + "## Build it" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f6caf5ba-364a-48dd-9ef0-8750cf39f966", + "metadata": {}, + "outputs": [], + "source": [ + "Path.init_localization('eellipse', center_coord=frb_coord, eellipse=eellipse)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5eaa3ff1-c8f8-40c8-849d-6e16ae5c7429", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'eellipse',\n", + " 'center_coord': ,\n", + " 'eellipse': {'a': 5, 'b': 5, 'theta': 0.0}}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Path.localiz" + ] + }, + { + "cell_type": "markdown", + "id": "fdcc22c3-f73f-4bf0-9dbb-76dba0905559", + "metadata": {}, + "source": [ + "# Galaxies" + ] + }, + { + "cell_type": "markdown", + "id": "133449b0-e2e5-4890-a5f0-6c982871997c", + "metadata": {}, + "source": [ + "## Positions" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8e95410a-225b-4d51-b106-100dd8977a1b", + "metadata": {}, + "outputs": [], + "source": [ + "# 1.0\" North, 1.0\" East\n", + "gal_coord1 = frb_coord.directional_offset_by(0.*units.deg, 1.0*units.arcsec)\n", + "gal_coord2 = frb_coord.directional_offset_by(90.*units.deg, 1.0*units.arcsec)" + ] + }, + { + "cell_type": "markdown", + "id": "8cdcbeee-d802-4df8-9b1b-b3fbb19abca8", + "metadata": {}, + "source": [ + "# Sizes" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9aa4a92b-ac36-443c-b3b2-fb483b72b4f1", + "metadata": {}, + "outputs": [], + "source": [ + "small_gal_size = np.array([1.]) # arcsec\n", + "tiny_gal_size = np.array([0.2]) # arcsec\n", + "box_hwidth = 50." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4f4e6d7f-978c-41a9-adac-838689d5be67", + "metadata": {}, + "outputs": [], + "source": [ + "box_hwidth = 90. # arcsec\n", + "step_size = 0.5 / 20 # arcsize" + ] + }, + { + "cell_type": "markdown", + "id": "fe49b2ec-ecd6-4617-aa25-b3cf76b7cd7f", + "metadata": {}, + "source": [ + "# Calculate" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "96193089-8446-4a6c-911b-d10b1fe40347", + "metadata": {}, + "outputs": [], + "source": [ + "# Set Equinox (for spherical offsets)\n", + "localiz = Path.localiz.copy()\n", + "localiz['center_coord'].equinox = gal_coord1.equinox" + ] + }, + { + "cell_type": "markdown", + "id": "8dada471-1d7d-45b8-8472-e7d5fb740295", + "metadata": {}, + "source": [ + "## Init the main grid :: $\\sim 0.1$s" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6106617f-b5cf-48ca-9079-76b58bcbb90b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "125 ms ± 3.72 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# Build the fixed grid around the transient\n", + "ngrid = int(np.round(2*box_hwidth / step_size))\n", + "x = np.linspace(-box_hwidth, box_hwidth, ngrid)\n", + "xcoord, ycoord = np.meshgrid(x,x)\n", + "\n", + "# Grid spacing\n", + "grid_spacing_arcsec = x[1]-x[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "2e926add-37d1-419d-9271-d47a7c47b846", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7200" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x.size" + ] + }, + { + "cell_type": "markdown", + "id": "a35631b4-0163-4a84-9cc8-0cdd020a4411", + "metadata": {}, + "source": [ + "## $L(w,x)$ :: $\\sim 10$s" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "3bad0ff5-c09a-4b6e-b7c0-ec2f9137beea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8.48 s ± 113 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# #####################\n", + "# L(w-x) -- 2D Gaussian, normalized to 1 when integrating over x not omega\n", + "# Approximate as flat sky\n", + "# Warning: RA increases in x for these grids!!\n", + "ra = localiz['center_coord'].ra.deg + \\\n", + " xcoord/3600. / np.cos(localiz['center_coord'].dec).value\n", + "dec = localiz['center_coord'].dec.deg + ycoord/3600.\n", + "L_wx = localization.calc_LWx(ra, dec, localiz)" + ] + }, + { + "cell_type": "markdown", + "id": "bc9064b9-e017-4691-ba85-56a01e0c9044", + "metadata": {}, + "source": [ + "## Offsets :: $\\sim 0.5$s" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "3f6b489c-04cd-44a0-8f5f-fc86a5b0226f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "474 ms ± 6.39 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# Offsets from the transient (approximate + flat sky)\n", + "cand_coord = gal_coord1\n", + "theta = 3600*np.sqrt(np.cos(cand_coord.dec).value**2 * (\n", + " ra-cand_coord.ra.deg)**2 + (dec-cand_coord.dec.deg)**2) # arc sec" + ] + }, + { + "cell_type": "markdown", + "id": "30595b71-0151-4a9d-9abc-8d60b9c2cac6", + "metadata": {}, + "source": [ + "## $p(w,O_i)$ :: $\\sim 0.1$s\n", + "\n", + "### This step could be sped up by cutting out a portion of the full grid" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "b6b2b319-2921-415e-8f9f-14ccdcd8fd9d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "110 ms ± 3.15 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# p(w|O_i)\n", + "p_wOi = bayesian.pw_Oi(theta,\n", + " 0.2, # arcsec\n", + " theta_prior)" + ] + }, + { + "cell_type": "markdown", + "id": "57242588-22bf-45dc-8fc7-102a7051d3d1", + "metadata": {}, + "source": [ + "## Product :: $\\sim 0.1$s" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "43c2d0db-2b2e-4a1f-a804-0bf9ff2b212f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "109 ms ± 782 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# Product\n", + "grid_p = L_wx * p_wOi" + ] + }, + { + "cell_type": "markdown", + "id": "b965a5d5-9e99-45bd-a2f7-aa1a78db18fb", + "metadata": {}, + "source": [ + "## Sum :: $\\sim 0.03$s" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "c71355e9-4572-4fa5-a2a5-361e255b3fb4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "26.3 ms ± 552 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "tsum = np.sum(grid_p)*grid_spacing_arcsec**2" + ] + }, + { + "cell_type": "markdown", + "id": "71061bb3-9c10-45f7-bd98-3b476421e56c", + "metadata": {}, + "source": [ + "----" + ] + }, + { + "cell_type": "markdown", + "id": "7c090381-6b31-4c39-9add-d0d6a2df96f8", + "metadata": {}, + "source": [ + "# Profile the Localization step" + ] + }, + { + "cell_type": "markdown", + "id": "13b39f5c-d739-4f84-bba4-74f6605d0a92", + "metadata": {}, + "source": [ + "## Setup the coords ($\\sim 0.8$s)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "08873c16-9049-4abe-b6f8-a4dd0b016d68", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "771 ms ± 31.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# Setup\n", + "eellipse = localiz['eellipse'] # convenience\n", + "pa_ee = eellipse['theta'] # PA of error ellipse on the sky; deg\n", + "dtheta = 90. - pa_ee # Rotation to place the semi-major axis \"a\" of the ellipse along the x-axis we define\n", + "#\n", + "coord = SkyCoord(ra=ra, dec=dec, unit='deg')\n", + "coord.equinox = localiz['center_coord'].equinox" + ] + }, + { + "cell_type": "markdown", + "id": "826a62ef-3086-4cfa-9407-74bdef72d4f5", + "metadata": {}, + "source": [ + "## Separation ($\\sim 3$s)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "7f0e8ddc-eb34-469a-b5c9-529914ce40e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.87 s ± 38.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# Rotate to the transient frame\n", + "sep_box = localiz['center_coord'].separation(coord).to('arcsec')" + ] + }, + { + "cell_type": "markdown", + "id": "bbd2f0bd-486e-47fa-8ee2-c4ded1907aca", + "metadata": {}, + "source": [ + "## PA ($\\sim 3$s)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "ae199478-ce4f-4dff-9ab2-7d6389d514f8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.01 s ± 34 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "pa_box = localiz['center_coord'].position_angle(coord).to('deg')\n", + "new_pa_box = pa_box + dtheta * units.deg" + ] + }, + { + "cell_type": "markdown", + "id": "1aa3a417-6aec-40a4-be53-b426e929ada0", + "metadata": {}, + "source": [ + "## $x,y$ ($\\sim 0.9$s)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "9fb79f71-3385-4581-9700-a275184f608e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "868 ms ± 8.78 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "# x, y of the box in transient frame with x along major axis\n", + "x_box = -sep_box.value * np.sin(new_pa_box).value\n", + "y_box = sep_box.value * np.cos(new_pa_box).value" + ] + }, + { + "cell_type": "markdown", + "id": "4d550d29-c411-4237-9985-95aa7365f591", + "metadata": {}, + "source": [ + "## $L(w,x)$ ($\\sim 0.7$s)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "b1ab4b00-081e-408b-8aca-f12f77383698", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "673 ms ± 18.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%%timeit\n", + "L_wx = np.exp(-x_box ** 2 / (2 * eellipse['a'] ** 2)) * np.exp(\n", + " -y_box ** 2 / (2 * eellipse['b'] ** 2)) / (2*np.pi*eellipse['a']*eellipse['b'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "386b39a8-fed9-444a-821b-cace96066cff", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/calculations/step_size/Steps_big_galaxy.ipynb b/calculations/step_size/Steps_big_galaxy.ipynb new file mode 100644 index 0000000..e968deb --- /dev/null +++ b/calculations/step_size/Steps_big_galaxy.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d7d37368-c3bf-409a-baed-92aa8ae7e4da", + "metadata": {}, + "source": [ + "# Experimenting with step size for a galaxy bigger than the localization" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "437a70b4-3383-4150-bd32-5cf699eaf30b", + "metadata": {}, + "outputs": [], + "source": [ + "# imports\n", + "from importlib import reload\n", + "import os\n", + "from importlib.resources import files as resource_files\n", + "\n", + "import numpy as np\n", + "\n", + "import pandas\n", + "\n", + "from astropy.coordinates import SkyCoord\n", + "from astropy.coordinates import offset_by\n", + "from astropy import units\n", + "#from astropy.io import fits\n", + "\n", + "from astropath import path\n", + "from astropath import localization\n", + "from astropath import bayesian" + ] + }, + { + "cell_type": "markdown", + "id": "fc737260-332c-4826-9175-43651e1b94fe", + "metadata": {}, + "source": [ + "# Convenience class" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f3eb095d-fe29-423a-915b-da42129781e3", + "metadata": {}, + "outputs": [], + "source": [ + "Path = path.PATH()" + ] + }, + { + "cell_type": "markdown", + "id": "b33b8175-ba4d-498f-a771-d3ab84506125", + "metadata": {}, + "source": [ + "# Faux FRB" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bca3fbb6-6452-4d56-b6ab-8a95242a7899", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## FRB Coord\n", + "frb_coord = SkyCoord('21h44m25.255s -40d54m00.10s', frame='icrs')\n", + "frb_coord" + ] + }, + { + "cell_type": "markdown", + "id": "6bcba1af-5912-4e0f-ac65-d34fe7ad13dc", + "metadata": {}, + "source": [ + "# Prior" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "e6fb9982-fc3d-435c-a2ed-1852c72bac51", + "metadata": {}, + "outputs": [], + "source": [ + "theta_prior = dict(max=6., PDF='exp', scale=1.)" + ] + }, + { + "cell_type": "markdown", + "id": "e104c1a9-2030-4280-bdf4-29a08eacca6e", + "metadata": {}, + "source": [ + "# Localization" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "73d77df6-8227-4041-914a-a8128291ac9a", + "metadata": {}, + "outputs": [], + "source": [ + "# Small, but not tiny\n", + "eellipse = dict(a=0.5, b=0.5, theta=0.)\n", + "# Tiny\n", + "tiny_eellipse = dict(a=0.1, b=0.1, theta=0.)" + ] + }, + { + "cell_type": "markdown", + "id": "a961b5e7-32b5-4c87-9461-4def50dbc1d6", + "metadata": {}, + "source": [ + "## Build it" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "f6caf5ba-364a-48dd-9ef0-8750cf39f966", + "metadata": {}, + "outputs": [], + "source": [ + "Path.init_localization('eellipse', center_coord=frb_coord, eellipse=eellipse)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "5eaa3ff1-c8f8-40c8-849d-6e16ae5c7429", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'eellipse',\n", + " 'center_coord': ,\n", + " 'eellipse': {'a': 0.5, 'b': 0.5, 'theta': 0.0}}" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Path.localiz" + ] + }, + { + "cell_type": "markdown", + "id": "fdcc22c3-f73f-4bf0-9dbb-76dba0905559", + "metadata": {}, + "source": [ + "# Galaxy" + ] + }, + { + "cell_type": "markdown", + "id": "133449b0-e2e5-4890-a5f0-6c982871997c", + "metadata": {}, + "source": [ + "## Position" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8e95410a-225b-4d51-b106-100dd8977a1b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " )" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 0.5\" North\n", + "gal_coord = frb_coord.directional_offset_by(0.*units.deg, 0.5*units.arcsec)\n", + "gal_coord, gal_coord.separation(frb_coord).to('arcsec')" + ] + }, + { + "cell_type": "markdown", + "id": "8cdcbeee-d802-4df8-9b1b-b3fbb19abca8", + "metadata": {}, + "source": [ + "## Size" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "9aa4a92b-ac36-443c-b3b2-fb483b72b4f1", + "metadata": {}, + "outputs": [], + "source": [ + "# Medium (5\")\n", + "gal_size = np.array([5.]) # arcsec\n", + "box_hwidth = 50." + ] + }, + { + "cell_type": "markdown", + "id": "fe49b2ec-ecd6-4617-aa25-b3cf76b7cd7f", + "metadata": {}, + "source": [ + "# Calculate" + ] + }, + { + "cell_type": "markdown", + "id": "c570e983-2743-4f8a-ac90-5b33a2942ebf", + "metadata": {}, + "source": [ + "## Tiny step_size" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "23333cb5-ccb0-4e95-bdc1-88723d227ab5", + "metadata": {}, + "outputs": [], + "source": [ + "reload(bayesian)\n", + "step_size = 0.05\n", + "L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid(box_hwidth, Path.localiz, np.array([gal_coord]),\n", + " gal_size, theta_prior, step_size=step_size, return_debug=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "c2b453a6-c164-45d1-9c0c-8c8aa08d682c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L_wx: 0.9990002500065099\n", + "p_wO: 0.9989995728142178\n", + "p_xO: 0.005565669003159662\n" + ] + } + ], + "source": [ + "print(f'L_wx: {np.sum(L_wx) * step_size**2}')\n", + "print(f'p_wO: {np.sum(p_wOi) * step_size**2}')\n", + "print(f'p_xO: {p_xOis}')" + ] + }, + { + "cell_type": "markdown", + "id": "b385ce97-f46c-44ee-aaac-27580cf666d0", + "metadata": {}, + "source": [ + "## Vary it" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "8c9bb78e-89f0-4707-af8e-103145d77e6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================\n", + "step: 0.05\n", + "L_wx: 0.9990002500065099\n", + "p_wO: 0.9989995728142178\n", + "p_xO_corr: 0.005571238849162845\n", + "p_xO: 0.005565669003159662\n", + "================================================\n", + "step: 0.1\n", + "L_wx: 0.9980009999805872\n", + "p_wO: 0.9980024191155251\n", + "p_xO_corr: 0.005576787526152111\n", + "p_xO: 0.005565639527779072\n", + "================================================\n", + "step: 0.25\n", + "L_wx: 0.9950062499888919\n", + "p_wO: 0.9950197864401361\n", + "p_xO_corr: 0.005593068199721013\n", + "p_xO: 0.005565137815336528\n", + "================================================\n", + "step: 0.5\n", + "L_wx: 0.9900249871353524\n", + "p_wO: 0.9899999465857889\n", + "p_xO_corr: 0.0056171414167946665\n", + "p_xO: 0.005561110358899594\n", + "================================================\n", + "step: 1.0\n", + "L_wx: 0.9492423957451299\n", + "p_wO: 0.9801137413800345\n", + "p_xO_corr: 0.005598644562157263\n", + "p_xO: 0.005314470777107605\n", + "================================================\n", + "step: 5.0\n", + "L_wx: 5.936931936520572e-11\n", + "p_wO: 0.8927383033791967\n", + "p_xO_corr: 0.003407067919875997\n", + "p_xO: 2.0227530343406521e-13\n" + ] + } + ], + "source": [ + "Path.init_localization('eellipse', center_coord=frb_coord, eellipse=eellipse)\n", + "Path.localiz\n", + "for step_size in [0.05, 0.1, 0.25, 0.5, 1., 5.]:\n", + " L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid(box_hwidth, Path.localiz, np.array([gal_coord]),\n", + " gal_size, theta_prior, step_size=step_size, return_debug=True)\n", + " print('================================================')\n", + " print(f'step: {step_size}')\n", + " print(f'L_wx: {np.sum(L_wx) * step_size**2}')\n", + " print(f'p_wO: {np.sum(p_wOi) * step_size**2}')\n", + " print(f'p_xO_corr: {p_xOis/np.sum(L_wx)/step_size**2}')\n", + " print(f'p_xO: {p_xOis}')" + ] + }, + { + "cell_type": "markdown", + "id": "a0bf9d0b-2b25-4214-a99c-82309657d956", + "metadata": {}, + "source": [ + "# Tiny localization, 5\" galaxy" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "6cf80d82-8175-4276-a7a8-d11dead4ddd0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================\n", + "step: 0.02\n", + "L_wx: 0.9996000399631986\n", + "p_wO: 0.9995974938858885\n", + "p_xO: 0.005851396503041362\n", + "p_xO_corr: 0.005853737764212962\n", + "================================================\n", + "step: 0.05\n", + "L_wx: 0.9990002500317912\n", + "p_wO: 0.9989995728142178\n", + "p_xO: 0.005851396502948485\n", + "p_xO_corr: 0.005857252290739943\n", + "================================================\n", + "step: 0.1\n", + "L_wx: 0.9980009889120542\n", + "p_wO: 0.9980024191155251\n", + "p_xO: 0.00585139640804566\n", + "p_xO_corr: 0.00586311684362599\n", + "================================================\n", + "step: 0.25\n", + "L_wx: 0.8306016683369597\n", + "p_wO: 0.9950197864401361\n", + "p_xO: 0.00487868135693966\n", + "p_xO_corr: 0.0058736715117702724\n", + "================================================\n", + "step: 0.5\n", + "L_wx: 0.028849033861050546\n", + "p_wO: 0.9899999465857889\n", + "p_xO: 0.0001685103560061478\n", + "p_xO_corr: 0.0058411091621912445\n", + "================================================\n", + "step: 1.0\n", + "L_wx: 5.32193597973942e-10\n", + "p_wO: 0.9801137413800345\n", + "p_xO: 2.9945296714021977e-12\n", + "p_xO_corr: 0.005626767557524847\n", + "================================================\n", + "step: 5.0\n", + "L_wx: 2.7788932288980924e-298\n", + "p_wO: 0.8927383033791967\n", + "p_xO: 9.465433682953108e-301\n", + "p_xO_corr: 0.0034061883286917115\n" + ] + } + ], + "source": [ + "Path.init_localization('eellipse', center_coord=frb_coord, eellipse=tiny_eellipse)\n", + "Path.localiz\n", + "for step_size in [0.02, 0.05, 0.1, 0.25, 0.5, 1., 5.]:\n", + " L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid(box_hwidth, Path.localiz, np.array([gal_coord]),\n", + " gal_size, theta_prior, step_size=step_size, return_debug=True)\n", + " print('================================================')\n", + " print(f'step: {step_size}')\n", + " print(f'L_wx: {np.sum(L_wx) * step_size**2}')\n", + " print(f'p_wO: {np.sum(p_wOi) * step_size**2}')\n", + " print(f'p_xO: {p_xOis}')\n", + " print(f'p_xO_corr: {p_xOis/np.sum(L_wx)/step_size**2}')\n", + " #print(f'p_xO_norm_norm: {p_xOis/np.sum(L_wx)/np.sum(p_wOi)/step_size**4}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96193089-8446-4a6c-911b-d10b1fe40347", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/calculations/step_size/Steps_small_galaxy.ipynb b/calculations/step_size/Steps_small_galaxy.ipynb new file mode 100644 index 0000000..e8ef066 --- /dev/null +++ b/calculations/step_size/Steps_small_galaxy.ipynb @@ -0,0 +1,405 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d7d37368-c3bf-409a-baed-92aa8ae7e4da", + "metadata": {}, + "source": [ + "# Experimenting with step size for a galaxy smaller than the ellipse" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "437a70b4-3383-4150-bd32-5cf699eaf30b", + "metadata": {}, + "outputs": [], + "source": [ + "# imports\n", + "from importlib import reload\n", + "import os\n", + "from importlib.resources import files as resource_files\n", + "\n", + "import numpy as np\n", + "\n", + "import pandas\n", + "\n", + "from astropy.coordinates import SkyCoord\n", + "from astropy.coordinates import offset_by\n", + "from astropy import units\n", + "#from astropy.io import fits\n", + "\n", + "from astropath import path\n", + "from astropath import localization\n", + "from astropath import bayesian" + ] + }, + { + "cell_type": "markdown", + "id": "fc737260-332c-4826-9175-43651e1b94fe", + "metadata": {}, + "source": [ + "# Convenience class" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f3eb095d-fe29-423a-915b-da42129781e3", + "metadata": {}, + "outputs": [], + "source": [ + "Path = path.PATH()" + ] + }, + { + "cell_type": "markdown", + "id": "b33b8175-ba4d-498f-a771-d3ab84506125", + "metadata": {}, + "source": [ + "# Faux FRB" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "bca3fbb6-6452-4d56-b6ab-8a95242a7899", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## FRB Coord\n", + "frb_coord = SkyCoord('21h44m25.255s -40d54m00.10s', frame='icrs')\n", + "frb_coord" + ] + }, + { + "cell_type": "markdown", + "id": "6bcba1af-5912-4e0f-ac65-d34fe7ad13dc", + "metadata": {}, + "source": [ + "# Prior" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e6fb9982-fc3d-435c-a2ed-1852c72bac51", + "metadata": {}, + "outputs": [], + "source": [ + "theta_prior = dict(max=6., PDF='exp', scale=1.)" + ] + }, + { + "cell_type": "markdown", + "id": "e104c1a9-2030-4280-bdf4-29a08eacca6e", + "metadata": {}, + "source": [ + "# Localization" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "73d77df6-8227-4041-914a-a8128291ac9a", + "metadata": {}, + "outputs": [], + "source": [ + "# Small, but not tiny\n", + "eellipse = dict(a=5, b=5, theta=0.)" + ] + }, + { + "cell_type": "markdown", + "id": "a961b5e7-32b5-4c87-9461-4def50dbc1d6", + "metadata": {}, + "source": [ + "## Build it" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f6caf5ba-364a-48dd-9ef0-8750cf39f966", + "metadata": {}, + "outputs": [], + "source": [ + "Path.init_localization('eellipse', center_coord=frb_coord, eellipse=eellipse)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "5eaa3ff1-c8f8-40c8-849d-6e16ae5c7429", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'eellipse',\n", + " 'center_coord': ,\n", + " 'eellipse': {'a': 5, 'b': 5, 'theta': 0.0}}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Path.localiz" + ] + }, + { + "cell_type": "markdown", + "id": "fdcc22c3-f73f-4bf0-9dbb-76dba0905559", + "metadata": {}, + "source": [ + "# Galaxy" + ] + }, + { + "cell_type": "markdown", + "id": "133449b0-e2e5-4890-a5f0-6c982871997c", + "metadata": {}, + "source": [ + "## Position" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8e95410a-225b-4d51-b106-100dd8977a1b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(,\n", + " )" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# 1.0\" North\n", + "gal_coord = frb_coord.directional_offset_by(0.*units.deg, 1.0*units.arcsec)\n", + "gal_coord, gal_coord.separation(frb_coord).to('arcsec')" + ] + }, + { + "cell_type": "markdown", + "id": "8cdcbeee-d802-4df8-9b1b-b3fbb19abca8", + "metadata": {}, + "source": [ + "## Size" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "9aa4a92b-ac36-443c-b3b2-fb483b72b4f1", + "metadata": {}, + "outputs": [], + "source": [ + "small_gal_size = np.array([1.]) # arcsec\n", + "tiny_gal_size = np.array([0.2]) # arcsec\n", + "box_hwidth = 50." + ] + }, + { + "cell_type": "markdown", + "id": "fe49b2ec-ecd6-4617-aa25-b3cf76b7cd7f", + "metadata": {}, + "source": [ + "# Calculate" + ] + }, + { + "cell_type": "markdown", + "id": "b385ce97-f46c-44ee-aaac-27580cf666d0", + "metadata": {}, + "source": [ + "## Small galaxy (1\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "8c9bb78e-89f0-4707-af8e-103145d77e6b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================\n", + "step: 0.01\n", + "L_wx: 0.9998000103183573\n", + "p_wO: 0.9997974697127257\n", + "p_xO: 0.005678161376930544\n", + "p_xO_corr: 0.005679311609542346\n", + "================================================\n", + "step: 0.1\n", + "L_wx: 0.998001000318597\n", + "p_wO: 0.9980224620716001\n", + "p_xO: 0.005678195745918647\n", + "p_xO_corr: 0.005689446842841982\n", + "================================================\n", + "step: 0.25\n", + "L_wx: 0.995006250316858\n", + "p_wO: 0.9949216063486281\n", + "p_xO: 0.0056773558179761905\n", + "p_xO_corr: 0.005706334832562478\n", + "================================================\n", + "step: 0.5\n", + "L_wx: 0.9900250003138782\n", + "p_wO: 0.9886994904374402\n", + "p_xO: 0.0056697174162953674\n", + "p_xO_corr: 0.005734520419128423\n", + "================================================\n", + "step: 1.0\n", + "L_wx: 0.9801000003123983\n", + "p_wO: 0.9702169732356216\n", + "p_xO: 0.00561310714089473\n", + "p_xO_corr: 0.005785414289522599\n", + "================================================\n", + "step: 5.0\n", + "L_wx: 0.9024999341095425\n", + "p_wO: 0.457497692474131\n", + "p_xO: 0.0024463480206865554\n", + "p_xO_corr: 0.005347235758626002\n" + ] + } + ], + "source": [ + "for step_size in [0.01, 0.1, 0.25, 0.5, 1., 5.]:\n", + " L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid(box_hwidth, Path.localiz, np.array([gal_coord]),\n", + " small_gal_size, theta_prior, step_size=step_size, return_debug=True)\n", + " print('================================================')\n", + " print(f'step: {step_size}')\n", + " print(f'L_wx: {np.sum(L_wx) * step_size**2}')\n", + " print(f'p_wO: {np.sum(p_wOi) * step_size**2}')\n", + " print(f'p_xO: {p_xOis}')\n", + " print(f'p_xO_corr: {p_xOis/np.sum(p_wOi)/step_size**2}')" + ] + }, + { + "cell_type": "markdown", + "id": "a0bf9d0b-2b25-4214-a99c-82309657d956", + "metadata": {}, + "source": [ + "# Tiny galaxy (0.2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "6cf80d82-8175-4276-a7a8-d11dead4ddd0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================================\n", + "step: 0.01\n", + "L_wx: 0.9998000103183573\n", + "p_wO: 0.9998049191069248\n", + "p_xO: 0.006214941133239931\n", + "p_xO_corr: 0.006216153786072012\n", + "================================================\n", + "step: 0.05\n", + "L_wx: 0.9990002503180448\n", + "p_wO: 0.998734557460303\n", + "p_xO: 0.00621326369200773\n", + "p_xO_corr: 0.00622113618237816\n", + "================================================\n", + "step: 0.1\n", + "L_wx: 0.998001000318597\n", + "p_wO: 0.9963147603287327\n", + "p_xO: 0.00620441779104315\n", + "p_xO_corr: 0.006227367131443492\n", + "================================================\n", + "step: 0.25\n", + "L_wx: 0.995006250316858\n", + "p_wO: 0.9775937336096671\n", + "p_xO: 0.006105245905153129\n", + "p_xO_corr: 0.006245177004776943\n", + "================================================\n", + "step: 0.5\n", + "L_wx: 0.9900250003138782\n", + "p_wO: 0.8572364100422724\n", + "p_xO: 0.005378097137839817\n", + "p_xO_corr: 0.006273761910759962\n", + "================================================\n", + "step: 1.0\n", + "L_wx: 0.9801000003123983\n", + "p_wO: 0.455664596376793\n", + "p_xO: 0.002873215741084444\n", + "p_xO_corr: 0.006305549660717017\n" + ] + } + ], + "source": [ + "for step_size in [0.01, 0.05, 0.1, 0.25, 0.5, 1.]:#, 5.]:\n", + " L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid(box_hwidth, Path.localiz, np.array([gal_coord]),\n", + " tiny_gal_size, theta_prior, step_size=step_size, return_debug=True)\n", + " print('================================================')\n", + " print(f'step: {step_size}')\n", + " print(f'L_wx: {np.sum(L_wx) * step_size**2}')\n", + " print(f'p_wO: {np.sum(p_wOi) * step_size**2}')\n", + " print(f'p_xO: {p_xOis}')\n", + " print(f'p_xO_corr: {p_xOis/np.sum(p_wOi)/step_size**2}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96193089-8446-4a6c-911b-d10b1fe40347", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/calculations/step_size/choose_step_size.ipynb b/calculations/step_size/choose_step_size.ipynb new file mode 100644 index 0000000..11c97d9 --- /dev/null +++ b/calculations/step_size/choose_step_size.ipynb @@ -0,0 +1,10665 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8bd8026f", + "metadata": {}, + "source": [ + "# Choosing PATH `step_size`\n", + "\n", + "The `step_size` parameter in PATH controls how finely the grid is sampled when calculating the likelihood `p(w|Oi)`. This needs to be small enough to finely sample both the localization size (`a` and `b`) and the galaxy angular size (`ang_size`). In this notebook, I try to figure out some method of choosing `step_size` to properly sample the convolution of the localization and galaxy size.\n", + "\n", + "The relevant code snippets are [here](https://github.com/FRBs/astropath/blob/d73ad5d552fc2694a8333e3b0815c9396ac0d427/astropath/run.py#L179) (setting the `step_size` parameter) and [here](https://github.com/FRBs/astropath/blob/d73ad5d552fc2694a8333e3b0815c9396ac0d427/astropath/bayesian.py#L189) (actually using `step_size` to calculate the likelihood grid). Note that, when calculating the likelihood, the original `step_size` is scaled by each galaxy size. Here's the relevant code snippet:\n", + "```\n", + "phi_cand = cand_ang_size[icand] # arcsec\n", + "step_size_phi = phi_cand * step_size # arcsec\n", + "box_hwidth = phi_cand * theta_prior['max'] # arcsec\n", + "\n", + "# Grid around the galaxy\n", + "ngrid = int(np.round(2 * box_hwidth / step_size_phi))\n", + "x = np.linspace(-box_hwidth, box_hwidth, ngrid)\n", + "xcoord, ycoord = np.meshgrid(x,x)\n", + "theta = np.sqrt(xcoord**2 + ycoord**2)\n", + "# p(w|O)\n", + "p_wOi = pw_Oi(theta, phi_cand, theta_prior)\n", + "```\n", + "So, we want `step_size` to be *small*. Currently, it is set as:\n", + "```\n", + "step_size_max = 2 * 3 * np.nanmin([a, b]) / np.nanmax(cut_catalog['ang_size'])\n", + "step_size = np.nanmin([0.1, step_size_max])\n", + "```\n", + "But that doesn't seem quite right..." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a32b7c85", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.pylab as pylab\n", + "params = {'axes.labelsize':20,\n", + " 'axes.titlesize':20,\n", + " 'xtick.labelsize':20,\n", + " 'ytick.labelsize':20}\n", + "pylab.rcParams.update(params)\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "13470608", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "from matplotlib.gridspec import GridSpec\n", + "from scipy.stats import norm" + ] + }, + { + "cell_type": "markdown", + "id": "06e2ed84", + "metadata": {}, + "source": [ + "## Question 1: How many samples do you need to smoothly integrate over a Gaussian distribution?\n", + "The convolution of the galaxy and localization will be roughly Gaussian. How fine does the sampling need to be to get a small error on the integral under the curve?" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "608f7d3d", + "metadata": {}, + "outputs": [], + "source": [ + "def pw_Oi(theta, phi, theta_prior):\n", + " \"\"\"\n", + " p(w|O_i) with corrected exp normalisation.\n", + " The fix: norm uses max/scale as the upper limit in units of phi_eff,\n", + " so the truncation (ok_w, in original-phi units) and the norm are consistent.\n", + " \"\"\"\n", + " p = np.zeros_like(theta, dtype=float)\n", + " ok_w = theta < theta_prior['max'] * phi # cutoff at max·phi_orig\n", + " \n", + " if theta_prior['PDF'] == 'core':\n", + " term0 = -phi**2 * np.log(phi)\n", + " term_max = phi * (theta_prior['max']*phi\n", + " - phi * np.log(phi + theta_prior['max']*phi))\n", + " norm = 2*np.pi*(term_max - term0)\n", + " if np.any(ok_w):\n", + " p[ok_w] = phi / (theta[ok_w] + phi) / norm\n", + " \n", + " elif theta_prior['PDF'] == 'uniform':\n", + " norm = np.pi * (phi * theta_prior['max'])**2\n", + " if np.any(ok_w):\n", + " p[ok_w] = 1.0 / norm\n", + " \n", + " elif theta_prior['PDF'] == 'exp':\n", + " phi_eff = phi * theta_prior['scale']\n", + " max_in_eff = theta_prior['max'] / theta_prior['scale'] # ← fix\n", + " norm = 2*np.pi * phi_eff**2 * (\n", + " 1 - (1 + max_in_eff) * np.exp(-max_in_eff))\n", + " if np.any(ok_w):\n", + " p[ok_w] = np.exp(-theta[ok_w] / phi_eff) / norm\n", + " else:\n", + " raise IOError(\"Bad theta PDF\")\n", + " \n", + " if norm == 0:\n", + " raise ValueError(\"Normalisation is zero!\")\n", + " return p\n", + " \n", + "def gaussian_localiz(xcoord, ycoord, r, a, b, pa_deg=0.):\n", + " \"\"\"\n", + " 2D Gaussian L(x-w) centred at (r, 0) with semi-axes a, b.\n", + " \n", + " pa_deg : position angle of major axis, East-of-North (degrees).\n", + " Here East = +x, North = +y, so PA rotates from y toward x.\n", + " \"\"\"\n", + " pa = np.deg2rad(pa_deg)\n", + " dx = xcoord - r\n", + " dy = ycoord\n", + " \n", + " # Rotate into ellipse frame\n", + " dx_r = dx * np.cos(pa) + dy * np.sin(pa)\n", + " dy_r = -dx * np.sin(pa) + dy * np.cos(pa)\n", + " \n", + " return np.exp(-0.5 * (dx_r**2/a**2 + dy_r**2/b**2)) / (2*np.pi*a*b)\n", + " \n", + "def build_grids(phi_cand, r, a, b, theta_prior, step_size, pa_deg=0.):\n", + " \"\"\"\n", + " Two grids:\n", + " integration_grid — strict PATH convention (box_hwidth = max·phi_cand)\n", + " plot_grid — extended to show the full Gaussian even when r is large\n", + " \"\"\"\n", + " step_size_phi = phi_cand * step_size\n", + " box_hwidth = phi_cand * theta_prior['max'] # PATH integration box\n", + " \n", + " # --- integration grid (matches px_Oi_local exactly) ---\n", + " ngrid_int = int(np.round(2 * box_hwidth / step_size_phi))\n", + " x_int = np.linspace(-box_hwidth, box_hwidth, ngrid_int)\n", + " xc_int, yc_int = np.meshgrid(x_int, x_int)\n", + " theta_int = np.sqrt(xc_int**2 + yc_int**2)\n", + " \n", + " p_wOi_int = pw_Oi(theta_int.ravel(), phi_cand, theta_prior\n", + " ).reshape(ngrid_int, ngrid_int)\n", + " L_int = gaussian_localiz(xc_int, yc_int, r, a, b, pa_deg)\n", + " integ_int = p_wOi_int * L_int\n", + " \n", + " p_xOi = np.nansum(integ_int) * step_size_phi**2 # ← the integral\n", + " \n", + " # sanity checks\n", + " check_pw = np.nansum(p_wOi_int) * step_size_phi**2\n", + " check_L = np.nansum(L_int) * step_size_phi**2\n", + " \n", + " # --- plot grid (extended) ---\n", + " box_plot = max(box_hwidth, r + 4*max(a, b))\n", + " ngrid_plt = int(np.round(2 * box_plot / step_size_phi))\n", + " x_plt = np.linspace(-box_plot, box_plot, ngrid_plt)\n", + " xc_plt, yc_plt = np.meshgrid(x_plt, x_plt)\n", + " theta_plt = np.sqrt(xc_plt**2 + yc_plt**2)\n", + " \n", + " p_wOi_plt = pw_Oi(theta_plt.ravel(), phi_cand, theta_prior\n", + " ).reshape(ngrid_plt, ngrid_plt)\n", + " L_plt = gaussian_localiz(xc_plt, yc_plt, r, a, b, pa_deg)\n", + " integ_plt = p_wOi_plt * L_plt\n", + " \n", + " return dict(\n", + " # integration result\n", + " p_xOi = p_xOi,\n", + " check_pw = check_pw,\n", + " check_L = check_L,\n", + " # integration grid\n", + " x_int=x_int, p_wOi_int=p_wOi_int, L_int=L_int, integ_int=integ_int,\n", + " step_size_phi=step_size_phi, box_hwidth=box_hwidth,\n", + " # plot grid\n", + " x_plt=x_plt, p_wOi_plt=p_wOi_plt, L_plt=L_plt, integ_plt=integ_plt,\n", + " box_plot=box_plot,\n", + " )\n", + " \n", + "def plot_convolution(phi_cand, r, a, b, theta_prior,\n", + " step_size=0.05, pa_deg=0., outfile=None):\n", + " \n", + " g = build_grids(phi_cand, r, a, b, theta_prior, step_size, pa_deg)\n", + " \n", + " print(f\"\\n{'='*55}\")\n", + " print(f\" phi_cand = {phi_cand}\\\" r = {r}\\\" a = {a}\\\" b = {b}\\\"\")\n", + " print(f\" step_size = {step_size} (step_size_phi = {g['step_size_phi']:.3f}\\\")\")\n", + " print(f\" Integration box half-width: {g['box_hwidth']:.1f}\\\"\")\n", + " print(f\" ∫ p(w|O_i) dA = {g['check_pw']:.6f} (should = 1)\")\n", + " print(f\" ∫ L(x-w) dA = {g['check_L']:.6f} (should ≈ 1)\")\n", + " print(f\" p(x|O_i) = {g['p_xOi']:.6f}\")\n", + " print(f\"{'='*55}\\n\")\n", + " \n", + " BG = '#0d0d0d'\n", + " fig = plt.figure(figsize=(15, 10), facecolor=BG)\n", + " gs = GridSpec(2, 3, figure=fig, wspace=0.38, hspace=0.45,\n", + " left=0.07, right=0.97, top=0.91, bottom=0.08)\n", + " \n", + " xp = g['x_plt']\n", + " ext = [-g['box_plot'], g['box_plot'], -g['box_plot'], g['box_plot']]\n", + " \n", + " panels = [\n", + " (g['p_wOi_plt'], r'$p(w\\,|\\,O_i)$',\n", + " 'magma', r'arcsec$^{-2}$'),\n", + " (g['L_plt'], r'$\\mathcal{L}(x{-}w)$',\n", + " 'viridis', r'arcsec$^{-2}$'),\n", + " (g['integ_plt'], r'$\\mathcal{L}(x{-}w)\\cdot p(w\\,|\\,O_i)$',\n", + " 'plasma', r'arcsec$^{-4}$'),\n", + " ]\n", + " \n", + " for col, (data, title, cmap, clabel) in enumerate(panels):\n", + " ax = fig.add_subplot(gs[0, col])\n", + " ax.set_facecolor(BG)\n", + " \n", + " vmax = np.nanpercentile(data[data > 0], 99.5) if np.any(data > 0) else 1\n", + " im = ax.imshow(data, origin='lower', extent=ext,\n", + " cmap=cmap, vmin=0, vmax=vmax,\n", + " aspect='equal', interpolation='bilinear')\n", + " \n", + " # Galaxy angular-size circle\n", + " ax.add_patch(plt.Circle((0, 0), phi_cand,\n", + " color='white', fill=False, lw=0.9, ls=':', alpha=0.6))\n", + " # Galaxy prior boundary\n", + " ax.add_patch(plt.Circle((0, 0), phi_cand * theta_prior['max'],\n", + " color='white', fill=False, lw=0.6, ls='--', alpha=0.35))\n", + " # Localization ellipse (1σ)\n", + " ax.add_patch(mpatches.Ellipse(\n", + " (r, 0), 2*a, 2*b, angle=pa_deg,\n", + " color='cyan', fill=False, lw=0.9, ls='--', alpha=0.7))\n", + " # Centres\n", + " ax.plot(0, 0, '+', color='white', ms=9, mew=1.4, alpha=0.9, zorder=5)\n", + " ax.plot(r, 0, 'x', color='cyan', ms=9, mew=1.4, alpha=0.9, zorder=5)\n", + " \n", + " ax.set_title(title, color='white', fontsize=10, pad=5)\n", + " ax.set_xlabel('ΔRA (arcsec)', color='#cccccc', fontsize=8)\n", + " if col == 0:\n", + " ax.set_ylabel('ΔDec (arcsec)', color='#cccccc', fontsize=8)\n", + " ax.tick_params(colors='#666666', labelsize=7)\n", + " for sp in ax.spines.values():\n", + " sp.set_edgecolor('#444444')\n", + " \n", + " cb = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.03)\n", + " cb.set_label(clabel, color='#aaaaaa', fontsize=6)\n", + " cb.ax.tick_params(labelsize=6, colors='#aaaaaa')\n", + " cb.outline.set_edgecolor('#444444')\n", + " \n", + " # ── 1D cuts ───────────────────────────────────────────────────────────────\n", + " \n", + " mid = len(xp) // 2 # row/col index for y=0 / x=0\n", + " r_idx = int(np.argmin(np.abs(xp - r))) # column index closest to x=r\n", + " \n", + " c_pw = '#ff7f50' # coral\n", + " c_L = '#90ee90' # light green\n", + " c_prod = '#87ceeb' # sky blue\n", + " \n", + " def _style_ax(ax, xlabel):\n", + " ax.set_facecolor(BG)\n", + " ax.set_xlabel(xlabel, color='#cccccc', fontsize=9)\n", + " ax.set_ylabel('Probability density', color='#cccccc', fontsize=9)\n", + " ax.tick_params(colors='#888888', labelsize=8)\n", + " for sp in ax.spines.values():\n", + " sp.set_edgecolor('#444444')\n", + " ax.legend(fontsize=8, facecolor='#1a1a1a',\n", + " labelcolor='white', edgecolor='#444444')\n", + " ax.axhline(0, color='#444444', lw=0.5)\n", + " \n", + " # Cut along ΔRA at Dec = 0\n", + " ax1 = fig.add_subplot(gs[1, :2])\n", + " ax1.plot(xp, g['p_wOi_plt'][mid, :], color=c_pw, lw=1.5,\n", + " label=r'$p(w|O_i)$')\n", + " ax1.plot(xp, g['L_plt'][mid, :], color=c_L, lw=1.5,\n", + " label=r'$\\mathcal{L}(x{-}w)$')\n", + " ax1.plot(xp, g['integ_plt'][mid, :], color=c_prod, lw=2.0,\n", + " label=r'$\\mathcal{L}\\cdot p(w|O_i)$')\n", + " ax1.axvline(0, color='white', lw=0.6, ls=':', alpha=0.5)\n", + " ax1.axvline(r, color='cyan', lw=0.6, ls='--', alpha=0.6)\n", + " \n", + " # shade the prior support\n", + " ax1.axvspan(-phi_cand*theta_prior['max'], phi_cand*theta_prior['max'],\n", + " alpha=0.05, color='white')\n", + " ax1.set_title('1D cut: ΔRA axis (ΔDec = 0)',\n", + " color='white', fontsize=10)\n", + " _style_ax(ax1, 'ΔRA (arcsec)')\n", + " \n", + " # Cut along ΔDec at RA = r\n", + " ax2 = fig.add_subplot(gs[1, 2])\n", + " ax2.plot(xp, g['p_wOi_plt'][:, r_idx], color=c_pw, lw=1.5,\n", + " label=r'$p(w|O_i)$')\n", + " ax2.plot(xp, g['L_plt'][:, r_idx], color=c_L, lw=1.5,\n", + " label=r'$\\mathcal{L}$')\n", + " ax2.plot(xp, g['integ_plt'][:, r_idx], color=c_prod, lw=2.0,\n", + " label=r'Product')\n", + " ax2.axvline(0, color='white', lw=0.6, ls=':', alpha=0.5)\n", + " ax2.set_title(f'1D cut: ΔDec axis (ΔRA = {r:.1f}\")',\n", + " color='white', fontsize=10)\n", + " _style_ax(ax2, 'ΔDec (arcsec)')\n", + " \n", + " # suptitle\n", + " fig.suptitle(\n", + " rf'$\\phi={phi_cand:.1f}$\" $r={r:.1f}$\" '\n", + " rf'$a={a:.1f}$\", $b={b:.1f}$\" '\n", + " rf'$\\Rightarrow\\; p(x|O_i) = {g[\"p_xOi\"]:.5f}$'\n", + " '\\n'\n", + " rf'[white $+$ = galaxy centre, cyan $\\times$ = localisation centre, '\n", + " rf'dotted circle = $\\phi$, dashed circle = max·$\\phi$]',\n", + " color='white', fontsize=11, y=0.995\n", + " )\n", + "\n", + "# fn = outfile or '~/frb_convolution.png'\n", + "# fig.savefig(fn, dpi=150, facecolor=BG)\n", + "# plt.close(fig)\n", + "# print(f\"Saved → {fn}\")\n", + " return g['p_xOi']" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "e5966ddf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.01 (step_size_phi = 0.010\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.998334 (should = 1)\n", + " ∫ L(x-w) dA = 0.998334 (should ≈ 1)\n", + " p(x|O_i) = 0.237034\n", + "=======================================================\n", + "\n" + ] + } + ], + "source": [ + "theta_prior = {'PDF': 'exp', 'scale': 0.5, 'max': 6.}\n", + "\n", + "phi_cand = 1. # Size of galaxy, arcsec\n", + "r = 0.5 # Galactocentric offset of localization, arcsec\n", + "a = 0.1 # Semi-major axis of 1sigma localization, arcsec\n", + "b = 0.05 # Semi-minor axis of 1sigma localization, arcsec\n", + "pa_deg = 10. # PA of localization\n", + "theta_prior = theta_prior\n", + "step_size = 0.01 # Step-size, as a fraction of phi_cand\n", + "\n", + "g = build_grids(phi_cand, r, a, b, theta_prior, step_size, pa_deg)\n", + "\n", + "print(f\"\\n{'='*55}\")\n", + "print(f\" phi_cand = {phi_cand}\\\" r = {r}\\\" a = {a}\\\" b = {b}\\\"\")\n", + "print(f\" step_size = {step_size} (step_size_phi = {g['step_size_phi']:.3f}\\\")\")\n", + "print(f\" Integration box half-width: {g['box_hwidth']:.1f}\\\"\")\n", + "print(f\" ∫ p(w|O_i) dA = {g['check_pw']:.6f} (should = 1)\")\n", + "print(f\" ∫ L(x-w) dA = {g['check_L']:.6f} (should ≈ 1)\")\n", + "print(f\" p(x|O_i) = {g['p_xOi']:.6f}\")\n", + "print(f\"{'='*55}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "b871debc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-3.0, 3.0)" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(16,8))\n", + "cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "\n", + "# (left, bottom, width, height)\n", + "sep_w = 0.1\n", + "sep_h = 0.1\n", + "bottom = 0.5\n", + "ax_exp = (0., bottom+sep_h, 0.3, 0.5)\n", + "ax_loc = (0.3+sep_w, bottom+sep_h, 0.3, 0.5)\n", + "ax_comb = (2*(0.3+sep_w), bottom+sep_h, 0.3, 0.5)\n", + "ax_racut = (0., 0., 0.5, 0.5)\n", + "ax_deccut = (0.5+sep_w, 0., 0.5, 0.5)\n", + "\n", + "xp = g['x_plt']\n", + "ext = [-g['box_plot'], g['box_plot'], -g['box_plot'], g['box_plot']]\n", + "\n", + "# Plot PDFs\n", + "\n", + "ax = plt.axes(ax_exp)\n", + "\n", + "data = g['p_wOi_plt']\n", + "vmax = np.nanpercentile(data[data > 0], 99.5) if np.any(data > 0) else 1\n", + "im = ax.imshow(\n", + " data, origin='lower', extent=ext,\n", + " cmap='viridis', vmin=0, vmax=vmax,\n", + " aspect='equal', interpolation='bilinear',\n", + ")\n", + "# Galaxy angular-size circle\n", + "ax.add_patch(plt.Circle((0, 0), phi_cand,\n", + " color='white', fill=False, lw=2, ls=':', alpha=0.6))\n", + "# Galaxy prior boundary\n", + "ax.add_patch(plt.Circle((0, 0), phi_cand * theta_prior['max'],\n", + " color='white', fill=False, lw=2, ls='--', alpha=0.35))\n", + "# Localization ellipse (3σ)\n", + "ax.add_patch(mpatches.Ellipse(\n", + " (r, 0), 3*a, 3*b, angle=pa_deg,\n", + " color='black', fill=False, lw=0.9, ls='-', alpha=0.7))\n", + "cb = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.03)\n", + "cb.set_label(r'arcsec$^{-2}$', color='black', fontsize=15)\n", + "ax.set_title(r'$p(w\\,|\\,O_i)$', color='black', fontsize=15, pad=5)\n", + "ax.set_xlabel('RA Offset (arcsec)', fontsize=15)\n", + "ax.set_ylabel('Dec Offset (arcsec)', color='black', fontsize=15)\n", + "\n", + "ax = plt.axes(ax_loc)\n", + "\n", + "data = g['L_plt']\n", + "vmax = np.nanpercentile(data[data > 0], 99.5) if np.any(data > 0) else 1\n", + "im = ax.imshow(\n", + " data, origin='lower', extent=ext,\n", + " cmap='viridis', vmin=0, vmax=vmax,\n", + " aspect='equal', interpolation='bilinear',\n", + ")\n", + "# Galaxy angular-size circle\n", + "ax.add_patch(plt.Circle((0, 0), phi_cand,\n", + " color='white', fill=False, lw=2, ls=':', alpha=0.6))\n", + "# Galaxy prior boundary\n", + "ax.add_patch(plt.Circle((0, 0), phi_cand * theta_prior['max'],\n", + " color='white', fill=False, lw=2, ls='--', alpha=0.35))\n", + "# Localization ellipse (3σ)\n", + "ax.add_patch(mpatches.Ellipse(\n", + " (r, 0), 3*a, 3*b, angle=pa_deg,\n", + " color='black', fill=False, lw=0.9, ls='-', alpha=0.7))\n", + "cb = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.03)\n", + "cb.set_label(r'arcsec$^{-2}$', color='black', fontsize=15)\n", + "ax.set_title(r'$L(x{-}w)$', color='black', fontsize=15, pad=5)\n", + "ax.set_xlabel('RA Offset (arcsec)', fontsize=15)\n", + "ax.set_ylabel('Dec Offset (arcsec)', color='black', fontsize=15)\n", + "\n", + "ax = plt.axes(ax_comb)\n", + "\n", + "data = g['integ_plt']\n", + "vmax = np.nanpercentile(data[data > 0], 99.5) if np.any(data > 0) else 1\n", + "im = ax.imshow(\n", + " data, origin='lower', extent=ext,\n", + " cmap='viridis', vmin=0, vmax=vmax,\n", + " aspect='equal', interpolation='bilinear',\n", + ")\n", + "# Galaxy angular-size circle\n", + "ax.add_patch(plt.Circle((0, 0), phi_cand,\n", + " color='white', fill=False, lw=2, ls=':', alpha=0.6))\n", + "# Galaxy prior boundary\n", + "ax.add_patch(plt.Circle((0, 0), phi_cand * theta_prior['max'],\n", + " color='white', fill=False, lw=2, ls='--', alpha=0.35))\n", + "# Localization ellipse (3σ)\n", + "ax.add_patch(mpatches.Ellipse(\n", + " (r, 0), 3*a, 3*b, angle=pa_deg,\n", + " color='black', fill=False, lw=0.9, ls='-', alpha=0.7))\n", + "cb = fig.colorbar(im, ax=ax, fraction=0.046, pad=0.03)\n", + "cb.set_label(r'arcsec$^{-4}$', color='black', fontsize=15)\n", + "ax.set_title(r'$L(x{-}w)\\cdot p(w\\,|\\,O_i)$', color='black', fontsize=15, pad=5)\n", + "ax.set_xlabel('RA Offset (arcsec)', fontsize=15)\n", + "ax.set_ylabel('Dec Offset (arcsec)', color='black', fontsize=15)\n", + "\n", + "# Plot cuts\n", + "mid = len(xp) // 2 # row/col index for y=0 / x=0\n", + "r_idx = int(np.argmin(np.abs(xp - r))) # column index closest to x=r\n", + "\n", + "ax = plt.axes(ax_racut)\n", + "\n", + "# Cut along ΔRA at Dec = 0\n", + "ax.plot(xp, g['p_wOi_plt'][mid, :] / np.nanmax(g['p_wOi_plt'][mid, :]), color=cycle[0], lw=1.5, label=r'$p(w|O_i)$')\n", + "ax.plot(xp, g['L_plt'][mid, :] / np.nanmax(g['L_plt'][mid, :]), color=cycle[1], lw=1.5, label=r'$L(x{-}w)$')\n", + "ax.plot(xp, g['integ_plt'][mid, :] / np.nanmax(g['integ_plt'][mid, :]), color=cycle[2], lw=2.0, label=r'$L \\cdot p(w|O_i)$')\n", + "ax.set_xlabel('RA Offset (arcsec)', color='black', fontsize=15)\n", + "ax.set_ylabel('Arbitrary Norm', color='black', fontsize=15)\n", + "ax.legend(fontsize=15)\n", + "ax.grid()\n", + "ax.set_xlim([-3,3])\n", + "\n", + "ax = plt.axes(ax_deccut)\n", + "\n", + "# Cut along ΔRA at Dec = 0\n", + "ax.plot(xp, g['p_wOi_plt'][:, r_idx] / np.nanmax(g['p_wOi_plt'][:, r_idx]), color=cycle[0], lw=1.5, label=r'$p(w|O_i)$')\n", + "ax.plot(xp, g['L_plt'][:, r_idx] / np.nanmax(g['L_plt'][:, r_idx]), color=cycle[1], lw=1.5, label=r'$L(x{-}w)$')\n", + "ax.plot(xp, g['integ_plt'][:, r_idx] / np.nanmax(g['integ_plt'][:, r_idx]), color=cycle[2], lw=2.0, label=r'$L \\cdot p(w|O_i)$')\n", + "ax.set_xlabel('Dec Offset (arcsec)', color='black', fontsize=15)\n", + "ax.set_ylabel('Arbitrary Norm', color='black', fontsize=15)\n", + "ax.legend(fontsize=15)\n", + "ax.grid()\n", + "ax.set_xlim([-3,3])" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "78967dca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04 (step_size_phi = 0.040\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.993339 (should = 1)\n", + " ∫ L(x-w) dA = 0.993344 (should ≈ 1)\n", + " p(x|O_i) = 0.235850\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.040360360360360364 (step_size_phi = 0.040\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991150 (should = 1)\n", + " ∫ L(x-w) dA = 0.991131 (should ≈ 1)\n", + " p(x|O_i) = 0.235324\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04072072072072072 (step_size_phi = 0.041\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.995340 (should = 1)\n", + " ∫ L(x-w) dA = 0.995321 (should ≈ 1)\n", + " p(x|O_i) = 0.236319\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.041081081081081085 (step_size_phi = 0.041\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992440 (should = 1)\n", + " ∫ L(x-w) dA = 0.992447 (should ≈ 1)\n", + " p(x|O_i) = 0.235636\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04144144144144144 (step_size_phi = 0.041\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.996094 (should = 1)\n", + " ∫ L(x-w) dA = 0.996100 (should ≈ 1)\n", + " p(x|O_i) = 0.236504\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.041801801801801805 (step_size_phi = 0.042\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992587 (should = 1)\n", + " ∫ L(x-w) dA = 0.992566 (should ≈ 1)\n", + " p(x|O_i) = 0.235665\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04216216216216216 (step_size_phi = 0.042\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.995702 (should = 1)\n", + " ∫ L(x-w) dA = 0.995680 (should ≈ 1)\n", + " p(x|O_i) = 0.236404\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.042522522522522525 (step_size_phi = 0.043\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991483 (should = 1)\n", + " ∫ L(x-w) dA = 0.991490 (should ≈ 1)\n", + " p(x|O_i) = 0.235409\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04288288288288288 (step_size_phi = 0.043\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.994056 (should = 1)\n", + " ∫ L(x-w) dA = 0.994063 (should ≈ 1)\n", + " p(x|O_i) = 0.236020\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.043243243243243246 (step_size_phi = 0.043\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.996392 (should = 1)\n", + " ∫ L(x-w) dA = 0.996400 (should ≈ 1)\n", + " p(x|O_i) = 0.236575\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0436036036036036 (step_size_phi = 0.044\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991274 (should = 1)\n", + " ∫ L(x-w) dA = 0.991250 (should ≈ 1)\n", + " p(x|O_i) = 0.235352\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.043963963963963966 (step_size_phi = 0.044\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.993070 (should = 1)\n", + " ∫ L(x-w) dA = 0.993045 (should ≈ 1)\n", + " p(x|O_i) = 0.235779\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04432432432432433 (step_size_phi = 0.044\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.994627 (should = 1)\n", + " ∫ L(x-w) dA = 0.994602 (should ≈ 1)\n", + " p(x|O_i) = 0.236148\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.044684684684684686 (step_size_phi = 0.045\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.995946 (should = 1)\n", + " ∫ L(x-w) dA = 0.995920 (should ≈ 1)\n", + " p(x|O_i) = 0.236461\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04504504504504504 (step_size_phi = 0.045\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989509 (should = 1)\n", + " ∫ L(x-w) dA = 0.989517 (should ≈ 1)\n", + " p(x|O_i) = 0.234941\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04540540540540541 (step_size_phi = 0.045\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990286 (should = 1)\n", + " ∫ L(x-w) dA = 0.990294 (should ≈ 1)\n", + " p(x|O_i) = 0.235125\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04576576576576577 (step_size_phi = 0.046\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990824 (should = 1)\n", + " ∫ L(x-w) dA = 0.990832 (should ≈ 1)\n", + " p(x|O_i) = 0.235253\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04612612612612613 (step_size_phi = 0.046\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991122 (should = 1)\n", + " ∫ L(x-w) dA = 0.991131 (should ≈ 1)\n", + " p(x|O_i) = 0.235324\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04648648648648649 (step_size_phi = 0.046\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991182 (should = 1)\n", + " ∫ L(x-w) dA = 0.991191 (should ≈ 1)\n", + " p(x|O_i) = 0.235338\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04684684684684685 (step_size_phi = 0.047\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991002 (should = 1)\n", + " ∫ L(x-w) dA = 0.991011 (should ≈ 1)\n", + " p(x|O_i) = 0.235296\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04720720720720721 (step_size_phi = 0.047\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990583 (should = 1)\n", + " ∫ L(x-w) dA = 0.990593 (should ≈ 1)\n", + " p(x|O_i) = 0.235196\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04756756756756757 (step_size_phi = 0.048\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989926 (should = 1)\n", + " ∫ L(x-w) dA = 0.989935 (should ≈ 1)\n", + " p(x|O_i) = 0.235040\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04792792792792793 (step_size_phi = 0.048\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989029 (should = 1)\n", + " ∫ L(x-w) dA = 0.989039 (should ≈ 1)\n", + " p(x|O_i) = 0.234827\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.048288288288288295 (step_size_phi = 0.048\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.995953 (should = 1)\n", + " ∫ L(x-w) dA = 0.995920 (should ≈ 1)\n", + " p(x|O_i) = 0.236461\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04864864864864865 (step_size_phi = 0.049\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.994635 (should = 1)\n", + " ∫ L(x-w) dA = 0.994602 (should ≈ 1)\n", + " p(x|O_i) = 0.236148\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04900900900900901 (step_size_phi = 0.049\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.993079 (should = 1)\n", + " ∫ L(x-w) dA = 0.993045 (should ≈ 1)\n", + " p(x|O_i) = 0.235779\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.04936936936936937 (step_size_phi = 0.049\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991285 (should = 1)\n", + " ∫ L(x-w) dA = 0.991250 (should ≈ 1)\n", + " p(x|O_i) = 0.235352\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.049729729729729735 (step_size_phi = 0.050\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989254 (should = 1)\n", + " ∫ L(x-w) dA = 0.989218 (should ≈ 1)\n", + " p(x|O_i) = 0.234870\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05009009009009009 (step_size_phi = 0.050\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.995250 (should = 1)\n", + " ∫ L(x-w) dA = 0.995261 (should ≈ 1)\n", + " p(x|O_i) = 0.236305\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.050450450450450456 (step_size_phi = 0.050\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992794 (should = 1)\n", + " ∫ L(x-w) dA = 0.992806 (should ≈ 1)\n", + " p(x|O_i) = 0.235722\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05081081081081081 (step_size_phi = 0.051\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990103 (should = 1)\n", + " ∫ L(x-w) dA = 0.990115 (should ≈ 1)\n", + " p(x|O_i) = 0.235083\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.051171171171171176 (step_size_phi = 0.051\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.995719 (should = 1)\n", + " ∫ L(x-w) dA = 0.995680 (should ≈ 1)\n", + " p(x|O_i) = 0.236404\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05153153153153153 (step_size_phi = 0.052\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992606 (should = 1)\n", + " ∫ L(x-w) dA = 0.992566 (should ≈ 1)\n", + " p(x|O_i) = 0.235665\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.051891891891891896 (step_size_phi = 0.052\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989259 (should = 1)\n", + " ∫ L(x-w) dA = 0.989218 (should ≈ 1)\n", + " p(x|O_i) = 0.234870\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05225225225225225 (step_size_phi = 0.052\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.994290 (should = 1)\n", + " ∫ L(x-w) dA = 0.994302 (should ≈ 1)\n", + " p(x|O_i) = 0.236077\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.052612612612612616 (step_size_phi = 0.053\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990520 (should = 1)\n", + " ∫ L(x-w) dA = 0.990533 (should ≈ 1)\n", + " p(x|O_i) = 0.235182\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05297297297297297 (step_size_phi = 0.053\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.995364 (should = 1)\n", + " ∫ L(x-w) dA = 0.995321 (should ≈ 1)\n", + " p(x|O_i) = 0.236319\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05333333333333334 (step_size_phi = 0.053\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991175 (should = 1)\n", + " ∫ L(x-w) dA = 0.991131 (should ≈ 1)\n", + " p(x|O_i) = 0.235324\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0536936936936937 (step_size_phi = 0.054\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986756 (should = 1)\n", + " ∫ L(x-w) dA = 0.986711 (should ≈ 1)\n", + " p(x|O_i) = 0.234275\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05405405405405406 (step_size_phi = 0.054\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990998 (should = 1)\n", + " ∫ L(x-w) dA = 0.991011 (should ≈ 1)\n", + " p(x|O_i) = 0.235296\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.054414414414414414 (step_size_phi = 0.054\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.995248 (should = 1)\n", + " ∫ L(x-w) dA = 0.995201 (should ≈ 1)\n", + " p(x|O_i) = 0.236290\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05477477477477478 (step_size_phi = 0.055\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990222 (should = 1)\n", + " ∫ L(x-w) dA = 0.990174 (should ≈ 1)\n", + " p(x|O_i) = 0.235097\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05513513513513514 (step_size_phi = 0.055\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.994048 (should = 1)\n", + " ∫ L(x-w) dA = 0.994063 (should ≈ 1)\n", + " p(x|O_i) = 0.236020\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0554954954954955 (step_size_phi = 0.055\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988606 (should = 1)\n", + " ∫ L(x-w) dA = 0.988621 (should ≈ 1)\n", + " p(x|O_i) = 0.234728\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.055855855855855854 (step_size_phi = 0.056\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992258 (should = 1)\n", + " ∫ L(x-w) dA = 0.992208 (should ≈ 1)\n", + " p(x|O_i) = 0.235580\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.056216216216216225 (step_size_phi = 0.056\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986405 (should = 1)\n", + " ∫ L(x-w) dA = 0.986353 (should ≈ 1)\n", + " p(x|O_i) = 0.234190\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05657657657657658 (step_size_phi = 0.057\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989621 (should = 1)\n", + " ∫ L(x-w) dA = 0.989636 (should ≈ 1)\n", + " p(x|O_i) = 0.234969\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05693693693693694 (step_size_phi = 0.057\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992859 (should = 1)\n", + " ∫ L(x-w) dA = 0.992806 (should ≈ 1)\n", + " p(x|O_i) = 0.235722\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0572972972972973 (step_size_phi = 0.057\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986408 (should = 1)\n", + " ∫ L(x-w) dA = 0.986353 (should ≈ 1)\n", + " p(x|O_i) = 0.234190\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.057657657657657665 (step_size_phi = 0.058\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989201 (should = 1)\n", + " ∫ L(x-w) dA = 0.989218 (should ≈ 1)\n", + " p(x|O_i) = 0.234870\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05801801801801802 (step_size_phi = 0.058\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992025 (should = 1)\n", + " ∫ L(x-w) dA = 0.991968 (should ≈ 1)\n", + " p(x|O_i) = 0.235523\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05837837837837838 (step_size_phi = 0.058\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.994584 (should = 1)\n", + " ∫ L(x-w) dA = 0.994602 (should ≈ 1)\n", + " p(x|O_i) = 0.236148\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05873873873873874 (step_size_phi = 0.059\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987350 (should = 1)\n", + " ∫ L(x-w) dA = 0.987367 (should ≈ 1)\n", + " p(x|O_i) = 0.234430\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.059099099099099106 (step_size_phi = 0.059\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989756 (should = 1)\n", + " ∫ L(x-w) dA = 0.989697 (should ≈ 1)\n", + " p(x|O_i) = 0.234984\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05945945945945946 (step_size_phi = 0.059\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991890 (should = 1)\n", + " ∫ L(x-w) dA = 0.991908 (should ≈ 1)\n", + " p(x|O_i) = 0.235508\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.05981981981981982 (step_size_phi = 0.060\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.994065 (should = 1)\n", + " ∫ L(x-w) dA = 0.994004 (should ≈ 1)\n", + " p(x|O_i) = 0.236006\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06018018018018018 (step_size_phi = 0.060\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986059 (should = 1)\n", + " ∫ L(x-w) dA = 0.985996 (should ≈ 1)\n", + " p(x|O_i) = 0.234105\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06054054054054055 (step_size_phi = 0.061\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987766 (should = 1)\n", + " ∫ L(x-w) dA = 0.987784 (should ≈ 1)\n", + " p(x|O_i) = 0.234529\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0609009009009009 (step_size_phi = 0.061\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989523 (should = 1)\n", + " ∫ L(x-w) dA = 0.989459 (should ≈ 1)\n", + " p(x|O_i) = 0.234927\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06126126126126127 (step_size_phi = 0.061\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990991 (should = 1)\n", + " ∫ L(x-w) dA = 0.991010 (should ≈ 1)\n", + " p(x|O_i) = 0.235295\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06162162162162163 (step_size_phi = 0.062\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992514 (should = 1)\n", + " ∫ L(x-w) dA = 0.992448 (should ≈ 1)\n", + " p(x|O_i) = 0.235637\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06198198198198199 (step_size_phi = 0.062\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.993743 (should = 1)\n", + " ∫ L(x-w) dA = 0.993762 (should ≈ 1)\n", + " p(x|O_i) = 0.235949\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.062342342342342344 (step_size_phi = 0.062\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984603 (should = 1)\n", + " ∫ L(x-w) dA = 0.984622 (should ≈ 1)\n", + " p(x|O_i) = 0.233778\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0627027027027027 (step_size_phi = 0.063\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985710 (should = 1)\n", + " ∫ L(x-w) dA = 0.985640 (should ≈ 1)\n", + " p(x|O_i) = 0.234020\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06306306306306307 (step_size_phi = 0.063\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986510 (should = 1)\n", + " ∫ L(x-w) dA = 0.986529 (should ≈ 1)\n", + " p(x|O_i) = 0.234231\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06342342342342343 (step_size_phi = 0.063\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987382 (should = 1)\n", + " ∫ L(x-w) dA = 0.987311 (should ≈ 1)\n", + " p(x|O_i) = 0.234417\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06378378378378378 (step_size_phi = 0.064\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987942 (should = 1)\n", + " ∫ L(x-w) dA = 0.987960 (should ≈ 1)\n", + " p(x|O_i) = 0.234571\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06414414414414416 (step_size_phi = 0.064\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988579 (should = 1)\n", + " ∫ L(x-w) dA = 0.988507 (should ≈ 1)\n", + " p(x|O_i) = 0.234701\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06450450450450451 (step_size_phi = 0.065\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988896 (should = 1)\n", + " ∫ L(x-w) dA = 0.988914 (should ≈ 1)\n", + " p(x|O_i) = 0.234798\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06486486486486487 (step_size_phi = 0.065\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989298 (should = 1)\n", + " ∫ L(x-w) dA = 0.989225 (should ≈ 1)\n", + " p(x|O_i) = 0.234872\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06522522522522523 (step_size_phi = 0.065\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989374 (should = 1)\n", + " ∫ L(x-w) dA = 0.989390 (should ≈ 1)\n", + " p(x|O_i) = 0.234911\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0655855855855856 (step_size_phi = 0.066\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989540 (should = 1)\n", + " ∫ L(x-w) dA = 0.989466 (should ≈ 1)\n", + " p(x|O_i) = 0.234929\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06594594594594595 (step_size_phi = 0.066\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989372 (should = 1)\n", + " ∫ L(x-w) dA = 0.989388 (should ≈ 1)\n", + " p(x|O_i) = 0.234910\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06630630630630631 (step_size_phi = 0.066\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989304 (should = 1)\n", + " ∫ L(x-w) dA = 0.989229 (should ≈ 1)\n", + " p(x|O_i) = 0.234873\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06666666666666668 (step_size_phi = 0.067\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988894 (should = 1)\n", + " ∫ L(x-w) dA = 0.988907 (should ≈ 1)\n", + " p(x|O_i) = 0.234796\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06702702702702704 (step_size_phi = 0.067\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988589 (should = 1)\n", + " ∫ L(x-w) dA = 0.988516 (should ≈ 1)\n", + " p(x|O_i) = 0.234704\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06738738738738739 (step_size_phi = 0.067\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987938 (should = 1)\n", + " ∫ L(x-w) dA = 0.987948 (should ≈ 1)\n", + " p(x|O_i) = 0.234568\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06774774774774775 (step_size_phi = 0.068\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987399 (should = 1)\n", + " ∫ L(x-w) dA = 0.987326 (should ≈ 1)\n", + " p(x|O_i) = 0.234421\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0681081081081081 (step_size_phi = 0.068\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986504 (should = 1)\n", + " ∫ L(x-w) dA = 0.986511 (should ≈ 1)\n", + " p(x|O_i) = 0.234227\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06846846846846848 (step_size_phi = 0.068\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985731 (should = 1)\n", + " ∫ L(x-w) dA = 0.985662 (should ≈ 1)\n", + " p(x|O_i) = 0.234026\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06882882882882883 (step_size_phi = 0.069\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984596 (should = 1)\n", + " ∫ L(x-w) dA = 0.984597 (should ≈ 1)\n", + " p(x|O_i) = 0.233772\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06918918918918919 (step_size_phi = 0.069\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983589 (should = 1)\n", + " ∫ L(x-w) dA = 0.983523 (should ≈ 1)\n", + " p(x|O_i) = 0.233518\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06954954954954956 (step_size_phi = 0.070\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.993861 (should = 1)\n", + " ∫ L(x-w) dA = 0.993795 (should ≈ 1)\n", + " p(x|O_i) = 0.235957\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.06990990990990992 (step_size_phi = 0.070\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992417 (should = 1)\n", + " ∫ L(x-w) dA = 0.992411 (should ≈ 1)\n", + " p(x|O_i) = 0.235627\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07027027027027027 (step_size_phi = 0.070\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991112 (should = 1)\n", + " ∫ L(x-w) dA = 0.991052 (should ≈ 1)\n", + " p(x|O_i) = 0.235306\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07063063063063063 (step_size_phi = 0.071\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989427 (should = 1)\n", + " ∫ L(x-w) dA = 0.989412 (should ≈ 1)\n", + " p(x|O_i) = 0.234915\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.070990990990991 (step_size_phi = 0.071\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987889 (should = 1)\n", + " ∫ L(x-w) dA = 0.987837 (should ≈ 1)\n", + " p(x|O_i) = 0.234543\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07135135135135136 (step_size_phi = 0.071\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985964 (should = 1)\n", + " ∫ L(x-w) dA = 0.985937 (should ≈ 1)\n", + " p(x|O_i) = 0.234089\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07171171171171171 (step_size_phi = 0.072\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984196 (should = 1)\n", + " ∫ L(x-w) dA = 0.984154 (should ≈ 1)\n", + " p(x|O_i) = 0.233669\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07207207207207209 (step_size_phi = 0.072\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982030 (should = 1)\n", + " ∫ L(x-w) dA = 0.981988 (should ≈ 1)\n", + " p(x|O_i) = 0.233152\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07243243243243244 (step_size_phi = 0.072\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991875 (should = 1)\n", + " ∫ L(x-w) dA = 0.991833 (should ≈ 1)\n", + " p(x|O_i) = 0.235489\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0727927927927928 (step_size_phi = 0.073\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989809 (should = 1)\n", + " ∫ L(x-w) dA = 0.989782 (should ≈ 1)\n", + " p(x|O_i) = 0.235006\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07315315315315316 (step_size_phi = 0.073\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987333 (should = 1)\n", + " ∫ L(x-w) dA = 0.987271 (should ≈ 1)\n", + " p(x|O_i) = 0.234406\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07351351351351351 (step_size_phi = 0.074\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985038 (should = 1)\n", + " ∫ L(x-w) dA = 0.985031 (should ≈ 1)\n", + " p(x|O_i) = 0.233878\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07387387387387388 (step_size_phi = 0.074\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982326 (should = 1)\n", + " ∫ L(x-w) dA = 0.982239 (should ≈ 1)\n", + " p(x|O_i) = 0.233210\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07423423423423424 (step_size_phi = 0.074\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991933 (should = 1)\n", + " ∫ L(x-w) dA = 0.991845 (should ≈ 1)\n", + " p(x|O_i) = 0.235491\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07459459459459461 (step_size_phi = 0.075\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989339 (should = 1)\n", + " ∫ L(x-w) dA = 0.989357 (should ≈ 1)\n", + " p(x|O_i) = 0.234906\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07495495495495497 (step_size_phi = 0.075\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986317 (should = 1)\n", + " ∫ L(x-w) dA = 0.986198 (should ≈ 1)\n", + " p(x|O_i) = 0.234149\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07531531531531532 (step_size_phi = 0.075\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983498 (should = 1)\n", + " ∫ L(x-w) dA = 0.983548 (should ≈ 1)\n", + " p(x|O_i) = 0.233527\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07567567567567568 (step_size_phi = 0.076\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992932 (should = 1)\n", + " ∫ L(x-w) dA = 0.992982 (should ≈ 1)\n", + " p(x|O_i) = 0.235767\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07603603603603604 (step_size_phi = 0.076\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989598 (should = 1)\n", + " ∫ L(x-w) dA = 0.989439 (should ≈ 1)\n", + " p(x|O_i) = 0.234918\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0763963963963964 (step_size_phi = 0.076\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986484 (should = 1)\n", + " ∫ L(x-w) dA = 0.986575 (should ≈ 1)\n", + " p(x|O_i) = 0.234247\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07675675675675676 (step_size_phi = 0.077\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982916 (should = 1)\n", + " ∫ L(x-w) dA = 0.982708 (should ≈ 1)\n", + " p(x|O_i) = 0.233319\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07711711711711713 (step_size_phi = 0.077\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992167 (should = 1)\n", + " ∫ L(x-w) dA = 0.991957 (should ≈ 1)\n", + " p(x|O_i) = 0.235515\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07747747747747749 (step_size_phi = 0.077\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988757 (should = 1)\n", + " ∫ L(x-w) dA = 0.988901 (should ≈ 1)\n", + " p(x|O_i) = 0.234800\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07783783783783785 (step_size_phi = 0.078\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984881 (should = 1)\n", + " ∫ L(x-w) dA = 0.984609 (should ≈ 1)\n", + " p(x|O_i) = 0.233770\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0781981981981982 (step_size_phi = 0.078\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981251 (should = 1)\n", + " ∫ L(x-w) dA = 0.981460 (should ≈ 1)\n", + " p(x|O_i) = 0.233035\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07855855855855856 (step_size_phi = 0.079\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990316 (should = 1)\n", + " ∫ L(x-w) dA = 0.990527 (should ≈ 1)\n", + " p(x|O_i) = 0.235187\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07891891891891892 (step_size_phi = 0.079\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986131 (should = 1)\n", + " ∫ L(x-w) dA = 0.985781 (should ≈ 1)\n", + " p(x|O_i) = 0.234046\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07927927927927929 (step_size_phi = 0.079\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982209 (should = 1)\n", + " ∫ L(x-w) dA = 0.982501 (should ≈ 1)\n", + " p(x|O_i) = 0.233283\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.07963963963963964 (step_size_phi = 0.080\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991158 (should = 1)\n", + " ∫ L(x-w) dA = 0.991453 (should ≈ 1)\n", + " p(x|O_i) = 0.235409\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08000000000000002 (step_size_phi = 0.080\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986667 (should = 1)\n", + " ∫ L(x-w) dA = 0.986219 (should ≈ 1)\n", + " p(x|O_i) = 0.234149\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08036036036036037 (step_size_phi = 0.080\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982453 (should = 1)\n", + " ∫ L(x-w) dA = 0.982849 (should ≈ 1)\n", + " p(x|O_i) = 0.233368\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08072072072072073 (step_size_phi = 0.081\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991284 (should = 1)\n", + " ∫ L(x-w) dA = 0.991683 (should ≈ 1)\n", + " p(x|O_i) = 0.235465\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08108108108108109 (step_size_phi = 0.081\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986485 (should = 1)\n", + " ∫ L(x-w) dA = 0.985918 (should ≈ 1)\n", + " p(x|O_i) = 0.234075\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08144144144144144 (step_size_phi = 0.081\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981983 (should = 1)\n", + " ∫ L(x-w) dA = 0.982507 (should ≈ 1)\n", + " p(x|O_i) = 0.233288\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08180180180180181 (step_size_phi = 0.082\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990693 (should = 1)\n", + " ∫ L(x-w) dA = 0.991221 (should ≈ 1)\n", + " p(x|O_i) = 0.235358\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08216216216216217 (step_size_phi = 0.082\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985589 (should = 1)\n", + " ∫ L(x-w) dA = 0.984875 (should ≈ 1)\n", + " p(x|O_i) = 0.233825\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08252252252252254 (step_size_phi = 0.083\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980799 (should = 1)\n", + " ∫ L(x-w) dA = 0.981481 (should ≈ 1)\n", + " p(x|O_i) = 0.233047\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0828828828828829 (step_size_phi = 0.083\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989384 (should = 1)\n", + " ∫ L(x-w) dA = 0.990072 (should ≈ 1)\n", + " p(x|O_i) = 0.235087\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08324324324324325 (step_size_phi = 0.083\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983978 (should = 1)\n", + " ∫ L(x-w) dA = 0.983084 (should ≈ 1)\n", + " p(x|O_i) = 0.233397\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08360360360360361 (step_size_phi = 0.084\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992516 (should = 1)\n", + " ∫ L(x-w) dA = 0.991614 (should ≈ 1)\n", + " p(x|O_i) = 0.235422\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08396396396396397 (step_size_phi = 0.084\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987361 (should = 1)\n", + " ∫ L(x-w) dA = 0.988243 (should ≈ 1)\n", + " p(x|O_i) = 0.234656\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08432432432432432 (step_size_phi = 0.084\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981654 (should = 1)\n", + " ∫ L(x-w) dA = 0.980541 (should ≈ 1)\n", + " p(x|O_i) = 0.232790\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0846846846846847 (step_size_phi = 0.085\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990062 (should = 1)\n", + " ∫ L(x-w) dA = 0.988939 (should ≈ 1)\n", + " p(x|O_i) = 0.234784\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08504504504504505 (step_size_phi = 0.085\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984625 (should = 1)\n", + " ∫ L(x-w) dA = 0.985743 (should ≈ 1)\n", + " p(x|O_i) = 0.234066\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08540540540540542 (step_size_phi = 0.085\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.992987 (should = 1)\n", + " ∫ L(x-w) dA = 0.994115 (should ≈ 1)\n", + " p(x|O_i) = 0.236054\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08576576576576578 (step_size_phi = 0.086\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986895 (should = 1)\n", + " ∫ L(x-w) dA = 0.985505 (should ≈ 1)\n", + " p(x|O_i) = 0.233965\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08612612612612613 (step_size_phi = 0.086\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981180 (should = 1)\n", + " ∫ L(x-w) dA = 0.982584 (should ≈ 1)\n", + " p(x|O_i) = 0.233320\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08648648648648649 (step_size_phi = 0.086\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989407 (should = 1)\n", + " ∫ L(x-w) dA = 0.990824 (should ≈ 1)\n", + " p(x|O_i) = 0.235277\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08684684684684685 (step_size_phi = 0.087\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983018 (should = 1)\n", + " ∫ L(x-w) dA = 0.981307 (should ≈ 1)\n", + " p(x|O_i) = 0.232964\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08720720720720722 (step_size_phi = 0.087\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991193 (should = 1)\n", + " ∫ L(x-w) dA = 0.989468 (should ≈ 1)\n", + " p(x|O_i) = 0.234901\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08756756756756758 (step_size_phi = 0.088\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985118 (should = 1)\n", + " ∫ L(x-w) dA = 0.986884 (should ≈ 1)\n", + " p(x|O_i) = 0.234346\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08792792792792795 (step_size_phi = 0.088\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978436 (should = 1)\n", + " ∫ L(x-w) dA = 0.976339 (should ≈ 1)\n", + " p(x|O_i) = 0.231779\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0882882882882883 (step_size_phi = 0.088\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986473 (should = 1)\n", + " ∫ L(x-w) dA = 0.984358 (should ≈ 1)\n", + " p(x|O_i) = 0.233683\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08864864864864866 (step_size_phi = 0.089\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980126 (should = 1)\n", + " ∫ L(x-w) dA = 0.982310 (should ≈ 1)\n", + " p(x|O_i) = 0.233265\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08900900900900902 (step_size_phi = 0.089\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988110 (should = 1)\n", + " ∫ L(x-w) dA = 0.990312 (should ≈ 1)\n", + " p(x|O_i) = 0.235166\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08936936936936937 (step_size_phi = 0.089\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981049 (should = 1)\n", + " ∫ L(x-w) dA = 0.978469 (should ≈ 1)\n", + " p(x|O_i) = 0.232279\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.08972972972972973 (step_size_phi = 0.090\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988977 (should = 1)\n", + " ∫ L(x-w) dA = 0.986376 (should ≈ 1)\n", + " p(x|O_i) = 0.234156\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0900900900900901 (step_size_phi = 0.090\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982277 (should = 1)\n", + " ∫ L(x-w) dA = 0.984983 (should ≈ 1)\n", + " p(x|O_i) = 0.233907\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09045045045045046 (step_size_phi = 0.090\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990151 (should = 1)\n", + " ∫ L(x-w) dA = 0.992879 (should ≈ 1)\n", + " p(x|O_i) = 0.235782\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09081081081081083 (step_size_phi = 0.091\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982712 (should = 1)\n", + " ∫ L(x-w) dA = 0.979554 (should ≈ 1)\n", + " p(x|O_i) = 0.232529\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09117117117117118 (step_size_phi = 0.091\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990527 (should = 1)\n", + " ∫ L(x-w) dA = 0.987343 (should ≈ 1)\n", + " p(x|O_i) = 0.234378\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09153153153153154 (step_size_phi = 0.092\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983478 (should = 1)\n", + " ∫ L(x-w) dA = 0.986810 (should ≈ 1)\n", + " p(x|O_i) = 0.234348\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0918918918918919 (step_size_phi = 0.092\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991237 (should = 1)\n", + " ∫ L(x-w) dA = 0.994595 (should ≈ 1)\n", + " p(x|O_i) = 0.236197\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09225225225225225 (step_size_phi = 0.092\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983424 (should = 1)\n", + " ∫ L(x-w) dA = 0.979574 (should ≈ 1)\n", + " p(x|O_i) = 0.232526\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09261261261261262 (step_size_phi = 0.093\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991122 (should = 1)\n", + " ∫ L(x-w) dA = 0.987242 (should ≈ 1)\n", + " p(x|O_i) = 0.234346\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09297297297297298 (step_size_phi = 0.093\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983727 (should = 1)\n", + " ∫ L(x-w) dA = 0.987805 (should ≈ 1)\n", + " p(x|O_i) = 0.234594\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09333333333333335 (step_size_phi = 0.093\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991368 (should = 1)\n", + " ∫ L(x-w) dA = 0.995477 (should ≈ 1)\n", + " p(x|O_i) = 0.236416\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09369369369369371 (step_size_phi = 0.094\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983182 (should = 1)\n", + " ∫ L(x-w) dA = 0.978511 (should ≈ 1)\n", + " p(x|O_i) = 0.232264\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09405405405405406 (step_size_phi = 0.094\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990760 (should = 1)\n", + " ∫ L(x-w) dA = 0.986052 (should ≈ 1)\n", + " p(x|O_i) = 0.234054\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09441441441441442 (step_size_phi = 0.094\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983024 (should = 1)\n", + " ∫ L(x-w) dA = 0.987988 (should ≈ 1)\n", + " p(x|O_i) = 0.234647\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09477477477477478 (step_size_phi = 0.095\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990542 (should = 1)\n", + " ∫ L(x-w) dA = 0.995545 (should ≈ 1)\n", + " p(x|O_i) = 0.236442\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09513513513513513 (step_size_phi = 0.095\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981989 (should = 1)\n", + " ∫ L(x-w) dA = 0.976344 (should ≈ 1)\n", + " p(x|O_i) = 0.231738\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0954954954954955 (step_size_phi = 0.095\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989442 (should = 1)\n", + " ∫ L(x-w) dA = 0.983755 (should ≈ 1)\n", + " p(x|O_i) = 0.233497\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09585585585585588 (step_size_phi = 0.096\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981369 (should = 1)\n", + " ∫ L(x-w) dA = 0.987382 (should ≈ 1)\n", + " p(x|O_i) = 0.234515\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09621621621621623 (step_size_phi = 0.096\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988762 (should = 1)\n", + " ∫ L(x-w) dA = 0.994820 (should ≈ 1)\n", + " p(x|O_i) = 0.236281\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09657657657657659 (step_size_phi = 0.097\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979843 (should = 1)\n", + " ∫ L(x-w) dA = 0.973053 (should ≈ 1)\n", + " p(x|O_i) = 0.230945\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09693693693693695 (step_size_phi = 0.097\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987169 (should = 1)\n", + " ∫ L(x-w) dA = 0.980328 (should ≈ 1)\n", + " p(x|O_i) = 0.232671\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.0972972972972973 (step_size_phi = 0.097\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978766 (should = 1)\n", + " ∫ L(x-w) dA = 0.986012 (should ≈ 1)\n", + " p(x|O_i) = 0.234202\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09765765765765766 (step_size_phi = 0.098\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986029 (should = 1)\n", + " ∫ L(x-w) dA = 0.993329 (should ≈ 1)\n", + " p(x|O_i) = 0.235940\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09801801801801803 (step_size_phi = 0.098\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976750 (should = 1)\n", + " ∫ L(x-w) dA = 0.968616 (should ≈ 1)\n", + " p(x|O_i) = 0.229877\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09837837837837839 (step_size_phi = 0.098\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983946 (should = 1)\n", + " ∫ L(x-w) dA = 0.975751 (should ≈ 1)\n", + " p(x|O_i) = 0.231571\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09873873873873876 (step_size_phi = 0.099\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991167 (should = 1)\n", + " ∫ L(x-w) dA = 0.982912 (should ≈ 1)\n", + " p(x|O_i) = 0.233270\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09909909909909911 (step_size_phi = 0.099\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982348 (should = 1)\n", + " ∫ L(x-w) dA = 0.991103 (should ≈ 1)\n", + " p(x|O_i) = 0.235426\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09945945945945947 (step_size_phi = 0.099\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989505 (should = 1)\n", + " ∫ L(x-w) dA = 0.998324 (should ≈ 1)\n", + " p(x|O_i) = 0.237142\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.09981981981981983 (step_size_phi = 0.100\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979776 (should = 1)\n", + " ∫ L(x-w) dA = 0.970000 (should ≈ 1)\n", + " p(x|O_i) = 0.230190\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10018018018018018 (step_size_phi = 0.100\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986863 (should = 1)\n", + " ∫ L(x-w) dA = 0.977017 (should ≈ 1)\n", + " p(x|O_i) = 0.231855\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10054054054054055 (step_size_phi = 0.101\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977724 (should = 1)\n", + " ∫ L(x-w) dA = 0.988174 (should ≈ 1)\n", + " p(x|O_i) = 0.234748\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10090090090090091 (step_size_phi = 0.101\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984746 (should = 1)\n", + " ∫ L(x-w) dA = 0.995271 (should ≈ 1)\n", + " p(x|O_i) = 0.236433\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10126126126126128 (step_size_phi = 0.101\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.991792 (should = 1)\n", + " ∫ L(x-w) dA = 1.002393 (should ≈ 1)\n", + " p(x|O_i) = 0.238125\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10162162162162164 (step_size_phi = 0.102\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981615 (should = 1)\n", + " ∫ L(x-w) dA = 0.969920 (should ≈ 1)\n", + " p(x|O_i) = 0.230153\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.101981981981982 (step_size_phi = 0.102\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988589 (should = 1)\n", + " ∫ L(x-w) dA = 0.976811 (should ≈ 1)\n", + " p(x|O_i) = 0.231788\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10234234234234235 (step_size_phi = 0.102\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979047 (should = 1)\n", + " ∫ L(x-w) dA = 0.991552 (should ≈ 1)\n", + " p(x|O_i) = 0.235569\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10270270270270271 (step_size_phi = 0.103\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985954 (should = 1)\n", + " ∫ L(x-w) dA = 0.998547 (should ≈ 1)\n", + " p(x|O_i) = 0.237231\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10306306306306307 (step_size_phi = 0.103\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975432 (should = 1)\n", + " ∫ L(x-w) dA = 0.961597 (should ≈ 1)\n", + " p(x|O_i) = 0.228157\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10342342342342342 (step_size_phi = 0.103\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982265 (should = 1)\n", + " ∫ L(x-w) dA = 0.968334 (should ≈ 1)\n", + " p(x|O_i) = 0.229756\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1037837837837838 (step_size_phi = 0.104\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989122 (should = 1)\n", + " ∫ L(x-w) dA = 0.975093 (should ≈ 1)\n", + " p(x|O_i) = 0.231359\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10414414414414416 (step_size_phi = 0.104\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979183 (should = 1)\n", + " ∫ L(x-w) dA = 0.994077 (should ≈ 1)\n", + " p(x|O_i) = 0.236190\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10450450450450452 (step_size_phi = 0.105\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985971 (should = 1)\n", + " ∫ L(x-w) dA = 1.000969 (should ≈ 1)\n", + " p(x|O_i) = 0.237827\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10486486486486488 (step_size_phi = 0.105\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975011 (should = 1)\n", + " ∫ L(x-w) dA = 0.958601 (should ≈ 1)\n", + " p(x|O_i) = 0.227424\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10522522522522523 (step_size_phi = 0.105\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981724 (should = 1)\n", + " ∫ L(x-w) dA = 0.965201 (should ≈ 1)\n", + " p(x|O_i) = 0.228989\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10558558558558559 (step_size_phi = 0.106\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988459 (should = 1)\n", + " ∫ L(x-w) dA = 0.971823 (should ≈ 1)\n", + " p(x|O_i) = 0.230560\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10594594594594595 (step_size_phi = 0.106\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978132 (should = 1)\n", + " ∫ L(x-w) dA = 0.995790 (should ≈ 1)\n", + " p(x|O_i) = 0.236620\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10630630630630633 (step_size_phi = 0.106\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984797 (should = 1)\n", + " ∫ L(x-w) dA = 1.002576 (should ≈ 1)\n", + " p(x|O_i) = 0.238232\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10666666666666669 (step_size_phi = 0.107\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973406 (should = 1)\n", + " ∫ L(x-w) dA = 0.954024 (should ≈ 1)\n", + " p(x|O_i) = 0.226312\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10702702702702704 (step_size_phi = 0.107\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979994 (should = 1)\n", + " ∫ L(x-w) dA = 0.960481 (should ≈ 1)\n", + " p(x|O_i) = 0.227844\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1073873873873874 (step_size_phi = 0.107\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986604 (should = 1)\n", + " ∫ L(x-w) dA = 0.966960 (should ≈ 1)\n", + " p(x|O_i) = 0.229381\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10774774774774776 (step_size_phi = 0.108\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975894 (should = 1)\n", + " ∫ L(x-w) dA = 0.996735 (should ≈ 1)\n", + " p(x|O_i) = 0.236870\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10810810810810811 (step_size_phi = 0.108\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982433 (should = 1)\n", + " ∫ L(x-w) dA = 1.003414 (should ≈ 1)\n", + " p(x|O_i) = 0.238457\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10846846846846847 (step_size_phi = 0.108\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988993 (should = 1)\n", + " ∫ L(x-w) dA = 1.010114 (should ≈ 1)\n", + " p(x|O_i) = 0.240050\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10882882882882883 (step_size_phi = 0.109\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977077 (should = 1)\n", + " ∫ L(x-w) dA = 0.954132 (should ≈ 1)\n", + " p(x|O_i) = 0.226309\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10918918918918921 (step_size_phi = 0.109\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983558 (should = 1)\n", + " ∫ L(x-w) dA = 0.960461 (should ≈ 1)\n", + " p(x|O_i) = 0.227811\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10954954954954957 (step_size_phi = 0.110\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.990061 (should = 1)\n", + " ∫ L(x-w) dA = 0.966811 (should ≈ 1)\n", + " p(x|O_i) = 0.229317\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.10990990990990993 (step_size_phi = 0.110\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978885 (should = 1)\n", + " ∫ L(x-w) dA = 1.003532 (should ≈ 1)\n", + " p(x|O_i) = 0.238514\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11027027027027028 (step_size_phi = 0.110\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985314 (should = 1)\n", + " ∫ L(x-w) dA = 1.010124 (should ≈ 1)\n", + " p(x|O_i) = 0.240081\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11063063063063064 (step_size_phi = 0.111\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972978 (should = 1)\n", + " ∫ L(x-w) dA = 0.946114 (should ≈ 1)\n", + " p(x|O_i) = 0.224376\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.110990990990991 (step_size_phi = 0.111\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979327 (should = 1)\n", + " ∫ L(x-w) dA = 0.952287 (should ≈ 1)\n", + " p(x|O_i) = 0.225840\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11135135135135135 (step_size_phi = 0.111\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985697 (should = 1)\n", + " ∫ L(x-w) dA = 0.958481 (should ≈ 1)\n", + " p(x|O_i) = 0.227309\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11171171171171174 (step_size_phi = 0.112\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974158 (should = 1)\n", + " ∫ L(x-w) dA = 1.002985 (should ≈ 1)\n", + " p(x|O_i) = 0.238415\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1120720720720721 (step_size_phi = 0.112\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980453 (should = 1)\n", + " ∫ L(x-w) dA = 1.009466 (should ≈ 1)\n", + " p(x|O_i) = 0.239955\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11243243243243245 (step_size_phi = 0.112\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986768 (should = 1)\n", + " ∫ L(x-w) dA = 1.015969 (should ≈ 1)\n", + " p(x|O_i) = 0.241501\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1127927927927928 (step_size_phi = 0.113\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973919 (should = 1)\n", + " ∫ L(x-w) dA = 0.942399 (should ≈ 1)\n", + " p(x|O_i) = 0.223460\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11315315315315316 (step_size_phi = 0.113\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980152 (should = 1)\n", + " ∫ L(x-w) dA = 0.948430 (should ≈ 1)\n", + " p(x|O_i) = 0.224890\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11351351351351352 (step_size_phi = 0.114\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986405 (should = 1)\n", + " ∫ L(x-w) dA = 0.954481 (should ≈ 1)\n", + " p(x|O_i) = 0.226325\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11387387387387388 (step_size_phi = 0.114\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974420 (should = 1)\n", + " ∫ L(x-w) dA = 1.008199 (should ≈ 1)\n", + " p(x|O_i) = 0.239688\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11423423423423426 (step_size_phi = 0.114\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980597 (should = 1)\n", + " ∫ L(x-w) dA = 1.014590 (should ≈ 1)\n", + " p(x|O_i) = 0.241207\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11459459459459462 (step_size_phi = 0.115\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986794 (should = 1)\n", + " ∫ L(x-w) dA = 1.021002 (should ≈ 1)\n", + " p(x|O_i) = 0.242732\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11495495495495497 (step_size_phi = 0.115\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973438 (should = 1)\n", + " ∫ L(x-w) dA = 0.936620 (should ≈ 1)\n", + " p(x|O_i) = 0.222052\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11531531531531533 (step_size_phi = 0.115\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979550 (should = 1)\n", + " ∫ L(x-w) dA = 0.942501 (should ≈ 1)\n", + " p(x|O_i) = 0.223446\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11567567567567569 (step_size_phi = 0.116\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985682 (should = 1)\n", + " ∫ L(x-w) dA = 0.948401 (should ≈ 1)\n", + " p(x|O_i) = 0.224845\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11603603603603604 (step_size_phi = 0.116\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973261 (should = 1)\n", + " ∫ L(x-w) dA = 1.012662 (should ≈ 1)\n", + " p(x|O_i) = 0.240785\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1163963963963964 (step_size_phi = 0.116\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979315 (should = 1)\n", + " ∫ L(x-w) dA = 1.018961 (should ≈ 1)\n", + " p(x|O_i) = 0.242283\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11675675675675676 (step_size_phi = 0.117\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985389 (should = 1)\n", + " ∫ L(x-w) dA = 1.025280 (should ≈ 1)\n", + " p(x|O_i) = 0.243786\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11711711711711714 (step_size_phi = 0.117\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971536 (should = 1)\n", + " ∫ L(x-w) dA = 0.928722 (should ≈ 1)\n", + " p(x|O_i) = 0.220138\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1174774774774775 (step_size_phi = 0.117\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977523 (should = 1)\n", + " ∫ L(x-w) dA = 0.934446 (should ≈ 1)\n", + " p(x|O_i) = 0.221495\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11783783783783786 (step_size_phi = 0.118\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983530 (should = 1)\n", + " ∫ L(x-w) dA = 0.940188 (should ≈ 1)\n", + " p(x|O_i) = 0.222856\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11819819819819821 (step_size_phi = 0.118\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989554 (should = 1)\n", + " ∫ L(x-w) dA = 0.945947 (should ≈ 1)\n", + " p(x|O_i) = 0.224221\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11855855855855857 (step_size_phi = 0.119\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976610 (should = 1)\n", + " ∫ L(x-w) dA = 1.022639 (should ≈ 1)\n", + " p(x|O_i) = 0.243197\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11891891891891893 (step_size_phi = 0.119\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982556 (should = 1)\n", + " ∫ L(x-w) dA = 1.028865 (should ≈ 1)\n", + " p(x|O_i) = 0.244677\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11927927927927928 (step_size_phi = 0.119\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988520 (should = 1)\n", + " ∫ L(x-w) dA = 1.035110 (should ≈ 1)\n", + " p(x|O_i) = 0.246162\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.11963963963963967 (step_size_phi = 0.120\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974073 (should = 1)\n", + " ∫ L(x-w) dA = 0.924214 (should ≈ 1)\n", + " p(x|O_i) = 0.219024\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12000000000000002 (step_size_phi = 0.120\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979950 (should = 1)\n", + " ∫ L(x-w) dA = 0.929790 (should ≈ 1)\n", + " p(x|O_i) = 0.220345\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12036036036036038 (step_size_phi = 0.120\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985844 (should = 1)\n", + " ∫ L(x-w) dA = 0.935382 (should ≈ 1)\n", + " p(x|O_i) = 0.221671\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12072072072072074 (step_size_phi = 0.121\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972489 (should = 1)\n", + " ∫ L(x-w) dA = 1.025685 (should ≈ 1)\n", + " p(x|O_i) = 0.243962\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1210810810810811 (step_size_phi = 0.121\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978304 (should = 1)\n", + " ∫ L(x-w) dA = 1.031818 (should ≈ 1)\n", + " p(x|O_i) = 0.245421\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12144144144144145 (step_size_phi = 0.121\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984135 (should = 1)\n", + " ∫ L(x-w) dA = 1.037968 (should ≈ 1)\n", + " p(x|O_i) = 0.246884\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1218018018018018 (step_size_phi = 0.122\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989985 (should = 1)\n", + " ∫ L(x-w) dA = 1.044138 (should ≈ 1)\n", + " p(x|O_i) = 0.248351\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12216216216216216 (step_size_phi = 0.122\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974953 (should = 1)\n", + " ∫ L(x-w) dA = 0.917161 (should ≈ 1)\n", + " p(x|O_i) = 0.217303\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12252252252252255 (step_size_phi = 0.123\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980714 (should = 1)\n", + " ∫ L(x-w) dA = 0.922580 (should ≈ 1)\n", + " p(x|O_i) = 0.218587\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1228828828828829 (step_size_phi = 0.123\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986491 (should = 1)\n", + " ∫ L(x-w) dA = 0.928015 (should ≈ 1)\n", + " p(x|O_i) = 0.219875\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12324324324324326 (step_size_phi = 0.123\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972640 (should = 1)\n", + " ∫ L(x-w) dA = 1.034199 (should ≈ 1)\n", + " p(x|O_i) = 0.246029\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12360360360360362 (step_size_phi = 0.124\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978336 (should = 1)\n", + " ∫ L(x-w) dA = 1.040256 (should ≈ 1)\n", + " p(x|O_i) = 0.247470\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12396396396396397 (step_size_phi = 0.124\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984049 (should = 1)\n", + " ∫ L(x-w) dA = 1.046330 (should ≈ 1)\n", + " p(x|O_i) = 0.248915\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12432432432432433 (step_size_phi = 0.124\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.989779 (should = 1)\n", + " ∫ L(x-w) dA = 1.052422 (should ≈ 1)\n", + " p(x|O_i) = 0.250365\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12468468468468469 (step_size_phi = 0.125\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974173 (should = 1)\n", + " ∫ L(x-w) dA = 0.907501 (should ≈ 1)\n", + " p(x|O_i) = 0.214961\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12504504504504507 (step_size_phi = 0.125\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979813 (should = 1)\n", + " ∫ L(x-w) dA = 0.912754 (should ≈ 1)\n", + " p(x|O_i) = 0.216206\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12540540540540543 (step_size_phi = 0.125\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985468 (should = 1)\n", + " ∫ L(x-w) dA = 0.918023 (should ≈ 1)\n", + " p(x|O_i) = 0.217454\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12576576576576579 (step_size_phi = 0.126\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971136 (should = 1)\n", + " ∫ L(x-w) dA = 1.042029 (should ≈ 1)\n", + " p(x|O_i) = 0.247935\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12612612612612614 (step_size_phi = 0.126\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976710 (should = 1)\n", + " ∫ L(x-w) dA = 1.048009 (should ≈ 1)\n", + " p(x|O_i) = 0.249358\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1264864864864865 (step_size_phi = 0.126\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982299 (should = 1)\n", + " ∫ L(x-w) dA = 1.054006 (should ≈ 1)\n", + " p(x|O_i) = 0.250785\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12684684684684686 (step_size_phi = 0.127\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987904 (should = 1)\n", + " ∫ L(x-w) dA = 1.060021 (should ≈ 1)\n", + " p(x|O_i) = 0.252216\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1272072072072072 (step_size_phi = 0.127\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971733 (should = 1)\n", + " ∫ L(x-w) dA = 0.895182 (should ≈ 1)\n", + " p(x|O_i) = 0.211986\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12756756756756757 (step_size_phi = 0.128\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977246 (should = 1)\n", + " ∫ L(x-w) dA = 0.900261 (should ≈ 1)\n", + " p(x|O_i) = 0.213189\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12792792792792795 (step_size_phi = 0.128\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982775 (should = 1)\n", + " ∫ L(x-w) dA = 0.905354 (should ≈ 1)\n", + " p(x|O_i) = 0.214395\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1282882882882883 (step_size_phi = 0.128\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988320 (should = 1)\n", + " ∫ L(x-w) dA = 0.910462 (should ≈ 1)\n", + " p(x|O_i) = 0.215605\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12864864864864867 (step_size_phi = 0.129\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973426 (should = 1)\n", + " ∫ L(x-w) dA = 1.055127 (should ≈ 1)\n", + " p(x|O_i) = 0.251096\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12900900900900902 (step_size_phi = 0.129\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978887 (should = 1)\n", + " ∫ L(x-w) dA = 1.061047 (should ≈ 1)\n", + " p(x|O_i) = 0.252505\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12936936936936938 (step_size_phi = 0.129\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984364 (should = 1)\n", + " ∫ L(x-w) dA = 1.066983 (should ≈ 1)\n", + " p(x|O_i) = 0.253917\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.12972972972972974 (step_size_phi = 0.130\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967641 (should = 1)\n", + " ∫ L(x-w) dA = 0.880163 (should ≈ 1)\n", + " p(x|O_i) = 0.208368\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1300900900900901 (step_size_phi = 0.130\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973024 (should = 1)\n", + " ∫ L(x-w) dA = 0.885059 (should ≈ 1)\n", + " p(x|O_i) = 0.209527\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13045045045045048 (step_size_phi = 0.130\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978422 (should = 1)\n", + " ∫ L(x-w) dA = 0.889969 (should ≈ 1)\n", + " p(x|O_i) = 0.210690\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13081081081081083 (step_size_phi = 0.131\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983835 (should = 1)\n", + " ∫ L(x-w) dA = 0.894893 (should ≈ 1)\n", + " p(x|O_i) = 0.211856\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1311711711711712 (step_size_phi = 0.131\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968497 (should = 1)\n", + " ∫ L(x-w) dA = 1.061651 (should ≈ 1)\n", + " p(x|O_i) = 0.252694\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13153153153153155 (step_size_phi = 0.132\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973826 (should = 1)\n", + " ∫ L(x-w) dA = 1.067493 (should ≈ 1)\n", + " p(x|O_i) = 0.254085\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1318918918918919 (step_size_phi = 0.132\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979169 (should = 1)\n", + " ∫ L(x-w) dA = 1.073350 (should ≈ 1)\n", + " p(x|O_i) = 0.255479\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13225225225225226 (step_size_phi = 0.132\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984527 (should = 1)\n", + " ∫ L(x-w) dA = 1.079223 (should ≈ 1)\n", + " p(x|O_i) = 0.256877\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13261261261261262 (step_size_phi = 0.133\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967153 (should = 1)\n", + " ∫ L(x-w) dA = 0.867123 (should ≈ 1)\n", + " p(x|O_i) = 0.205215\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.132972972972973 (step_size_phi = 0.133\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972417 (should = 1)\n", + " ∫ L(x-w) dA = 0.871842 (should ≈ 1)\n", + " p(x|O_i) = 0.206332\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13333333333333336 (step_size_phi = 0.133\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977694 (should = 1)\n", + " ∫ L(x-w) dA = 0.876574 (should ≈ 1)\n", + " p(x|O_i) = 0.207452\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13369369369369372 (step_size_phi = 0.134\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982986 (should = 1)\n", + " ∫ L(x-w) dA = 0.881318 (should ≈ 1)\n", + " p(x|O_i) = 0.208575\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13405405405405407 (step_size_phi = 0.134\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988293 (should = 1)\n", + " ∫ L(x-w) dA = 0.886076 (should ≈ 1)\n", + " p(x|O_i) = 0.209701\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13441441441441443 (step_size_phi = 0.134\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972332 (should = 1)\n", + " ∫ L(x-w) dA = 1.079156 (should ≈ 1)\n", + " p(x|O_i) = 0.256912\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13477477477477479 (step_size_phi = 0.135\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977552 (should = 1)\n", + " ∫ L(x-w) dA = 1.084950 (should ≈ 1)\n", + " p(x|O_i) = 0.258291\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13513513513513514 (step_size_phi = 0.135\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982787 (should = 1)\n", + " ∫ L(x-w) dA = 1.090759 (should ≈ 1)\n", + " p(x|O_i) = 0.259674\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1354954954954955 (step_size_phi = 0.135\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988035 (should = 1)\n", + " ∫ L(x-w) dA = 1.096584 (should ≈ 1)\n", + " p(x|O_i) = 0.261061\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13585585585585588 (step_size_phi = 0.136\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969918 (should = 1)\n", + " ∫ L(x-w) dA = 0.855495 (should ≈ 1)\n", + " p(x|O_i) = 0.202392\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13621621621621624 (step_size_phi = 0.136\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975071 (should = 1)\n", + " ∫ L(x-w) dA = 0.860040 (should ≈ 1)\n", + " p(x|O_i) = 0.203467\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1365765765765766 (step_size_phi = 0.137\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980236 (should = 1)\n", + " ∫ L(x-w) dA = 0.864596 (should ≈ 1)\n", + " p(x|O_i) = 0.204545\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13693693693693695 (step_size_phi = 0.137\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985416 (should = 1)\n", + " ∫ L(x-w) dA = 0.869165 (should ≈ 1)\n", + " p(x|O_i) = 0.205626\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1372972972972973 (step_size_phi = 0.137\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968948 (should = 1)\n", + " ∫ L(x-w) dA = 1.090146 (should ≈ 1)\n", + " p(x|O_i) = 0.259589\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13765765765765767 (step_size_phi = 0.138\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974041 (should = 1)\n", + " ∫ L(x-w) dA = 1.095876 (should ≈ 1)\n", + " p(x|O_i) = 0.260954\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13801801801801802 (step_size_phi = 0.138\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979148 (should = 1)\n", + " ∫ L(x-w) dA = 1.101621 (should ≈ 1)\n", + " p(x|O_i) = 0.262322\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1383783783783784 (step_size_phi = 0.138\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984268 (should = 1)\n", + " ∫ L(x-w) dA = 1.107382 (should ≈ 1)\n", + " p(x|O_i) = 0.263693\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13873873873873876 (step_size_phi = 0.139\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965532 (should = 1)\n", + " ∫ L(x-w) dA = 0.836004 (should ≈ 1)\n", + " p(x|O_i) = 0.197703\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13909909909909912 (step_size_phi = 0.139\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970554 (should = 1)\n", + " ∫ L(x-w) dA = 0.840352 (should ≈ 1)\n", + " p(x|O_i) = 0.198731\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13945945945945948 (step_size_phi = 0.139\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975589 (should = 1)\n", + " ∫ L(x-w) dA = 0.844712 (should ≈ 1)\n", + " p(x|O_i) = 0.199762\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.13981981981981983 (step_size_phi = 0.140\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980638 (should = 1)\n", + " ∫ L(x-w) dA = 0.849083 (should ≈ 1)\n", + " p(x|O_i) = 0.200796\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1401801801801802 (step_size_phi = 0.140\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985699 (should = 1)\n", + " ∫ L(x-w) dA = 0.853466 (should ≈ 1)\n", + " p(x|O_i) = 0.201832\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14054054054054055 (step_size_phi = 0.141\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968650 (should = 1)\n", + " ∫ L(x-w) dA = 1.106173 (should ≈ 1)\n", + " p(x|O_i) = 0.263482\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1409009009009009 (step_size_phi = 0.141\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973623 (should = 1)\n", + " ∫ L(x-w) dA = 1.111853 (should ≈ 1)\n", + " p(x|O_i) = 0.264835\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1412612612612613 (step_size_phi = 0.141\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978610 (should = 1)\n", + " ∫ L(x-w) dA = 1.117548 (should ≈ 1)\n", + " p(x|O_i) = 0.266192\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14162162162162165 (step_size_phi = 0.142\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983609 (should = 1)\n", + " ∫ L(x-w) dA = 1.123257 (should ≈ 1)\n", + " p(x|O_i) = 0.267551\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.141981981981982 (step_size_phi = 0.142\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.988621 (should = 1)\n", + " ∫ L(x-w) dA = 1.128980 (should ≈ 1)\n", + " p(x|O_i) = 0.268915\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14234234234234236 (step_size_phi = 0.142\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969057 (should = 1)\n", + " ∫ L(x-w) dA = 0.821675 (should ≈ 1)\n", + " p(x|O_i) = 0.194229\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14270270270270272 (step_size_phi = 0.143\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973970 (should = 1)\n", + " ∫ L(x-w) dA = 0.825841 (should ≈ 1)\n", + " p(x|O_i) = 0.195214\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14306306306306307 (step_size_phi = 0.143\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978896 (should = 1)\n", + " ∫ L(x-w) dA = 0.830017 (should ≈ 1)\n", + " p(x|O_i) = 0.196201\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14342342342342343 (step_size_phi = 0.143\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983833 (should = 1)\n", + " ∫ L(x-w) dA = 0.834204 (should ≈ 1)\n", + " p(x|O_i) = 0.197191\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14378378378378381 (step_size_phi = 0.144\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966228 (should = 1)\n", + " ∫ L(x-w) dA = 1.121528 (should ≈ 1)\n", + " p(x|O_i) = 0.267235\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14414414414414417 (step_size_phi = 0.144\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971077 (should = 1)\n", + " ∫ L(x-w) dA = 1.127157 (should ≈ 1)\n", + " p(x|O_i) = 0.268576\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14450450450450453 (step_size_phi = 0.145\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975939 (should = 1)\n", + " ∫ L(x-w) dA = 1.132799 (should ≈ 1)\n", + " p(x|O_i) = 0.269920\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14486486486486488 (step_size_phi = 0.145\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980812 (should = 1)\n", + " ∫ L(x-w) dA = 1.138456 (should ≈ 1)\n", + " p(x|O_i) = 0.271268\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14522522522522524 (step_size_phi = 0.145\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985698 (should = 1)\n", + " ∫ L(x-w) dA = 1.144127 (should ≈ 1)\n", + " p(x|O_i) = 0.272620\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1455855855855856 (step_size_phi = 0.146\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965437 (should = 1)\n", + " ∫ L(x-w) dA = 0.799472 (should ≈ 1)\n", + " p(x|O_i) = 0.188890\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14594594594594595 (step_size_phi = 0.146\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970222 (should = 1)\n", + " ∫ L(x-w) dA = 0.803435 (should ≈ 1)\n", + " p(x|O_i) = 0.189826\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14630630630630634 (step_size_phi = 0.146\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975019 (should = 1)\n", + " ∫ L(x-w) dA = 0.807407 (should ≈ 1)\n", + " p(x|O_i) = 0.190765\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1466666666666667 (step_size_phi = 0.147\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979828 (should = 1)\n", + " ∫ L(x-w) dA = 0.811390 (should ≈ 1)\n", + " p(x|O_i) = 0.191706\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14702702702702705 (step_size_phi = 0.147\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984649 (should = 1)\n", + " ∫ L(x-w) dA = 0.815382 (should ≈ 1)\n", + " p(x|O_i) = 0.192649\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1473873873873874 (step_size_phi = 0.147\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966415 (should = 1)\n", + " ∫ L(x-w) dA = 1.141900 (should ≈ 1)\n", + " p(x|O_i) = 0.272196\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14774774774774777 (step_size_phi = 0.148\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971147 (should = 1)\n", + " ∫ L(x-w) dA = 1.147491 (should ≈ 1)\n", + " p(x|O_i) = 0.273529\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14810810810810812 (step_size_phi = 0.148\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975890 (should = 1)\n", + " ∫ L(x-w) dA = 1.153095 (should ≈ 1)\n", + " p(x|O_i) = 0.274864\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14846846846846848 (step_size_phi = 0.148\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980645 (should = 1)\n", + " ∫ L(x-w) dA = 1.158713 (should ≈ 1)\n", + " p(x|O_i) = 0.276204\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14882882882882884 (step_size_phi = 0.149\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985411 (should = 1)\n", + " ∫ L(x-w) dA = 1.164345 (should ≈ 1)\n", + " p(x|O_i) = 0.277546\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14918918918918922 (step_size_phi = 0.149\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964353 (should = 1)\n", + " ∫ L(x-w) dA = 0.777536 (should ≈ 1)\n", + " p(x|O_i) = 0.183612\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14954954954954958 (step_size_phi = 0.150\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969017 (should = 1)\n", + " ∫ L(x-w) dA = 0.781296 (should ≈ 1)\n", + " p(x|O_i) = 0.184500\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.14990990990990993 (step_size_phi = 0.150\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973693 (should = 1)\n", + " ∫ L(x-w) dA = 0.785066 (should ≈ 1)\n", + " p(x|O_i) = 0.185390\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1502702702702703 (step_size_phi = 0.150\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978379 (should = 1)\n", + " ∫ L(x-w) dA = 0.788845 (should ≈ 1)\n", + " p(x|O_i) = 0.186283\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15063063063063065 (step_size_phi = 0.151\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983077 (should = 1)\n", + " ∫ L(x-w) dA = 0.792633 (should ≈ 1)\n", + " p(x|O_i) = 0.187177\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.150990990990991 (step_size_phi = 0.151\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964246 (should = 1)\n", + " ∫ L(x-w) dA = 1.161762 (should ≈ 1)\n", + " p(x|O_i) = 0.277027\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15135135135135136 (step_size_phi = 0.151\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968854 (should = 1)\n", + " ∫ L(x-w) dA = 1.167314 (should ≈ 1)\n", + " p(x|O_i) = 0.278351\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15171171171171174 (step_size_phi = 0.152\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973473 (should = 1)\n", + " ∫ L(x-w) dA = 1.172880 (should ≈ 1)\n", + " p(x|O_i) = 0.279678\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1520720720720721 (step_size_phi = 0.152\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978104 (should = 1)\n", + " ∫ L(x-w) dA = 1.178458 (should ≈ 1)\n", + " p(x|O_i) = 0.281008\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15243243243243246 (step_size_phi = 0.152\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982745 (should = 1)\n", + " ∫ L(x-w) dA = 1.184050 (should ≈ 1)\n", + " p(x|O_i) = 0.282342\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15279279279279281 (step_size_phi = 0.153\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.987397 (should = 1)\n", + " ∫ L(x-w) dA = 1.189655 (should ≈ 1)\n", + " p(x|O_i) = 0.283678\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15315315315315317 (step_size_phi = 0.153\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965452 (should = 1)\n", + " ∫ L(x-w) dA = 0.755318 (should ≈ 1)\n", + " p(x|O_i) = 0.178271\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15351351351351353 (step_size_phi = 0.154\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970001 (should = 1)\n", + " ∫ L(x-w) dA = 0.758876 (should ≈ 1)\n", + " p(x|O_i) = 0.179111\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15387387387387388 (step_size_phi = 0.154\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974560 (should = 1)\n", + " ∫ L(x-w) dA = 0.762443 (should ≈ 1)\n", + " p(x|O_i) = 0.179952\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15423423423423424 (step_size_phi = 0.154\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979130 (should = 1)\n", + " ∫ L(x-w) dA = 0.766019 (should ≈ 1)\n", + " p(x|O_i) = 0.180796\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15459459459459463 (step_size_phi = 0.155\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983711 (should = 1)\n", + " ∫ L(x-w) dA = 0.769602 (should ≈ 1)\n", + " p(x|O_i) = 0.181642\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15495495495495498 (step_size_phi = 0.155\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964209 (should = 1)\n", + " ∫ L(x-w) dA = 1.186735 (should ≈ 1)\n", + " p(x|O_i) = 0.283026\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15531531531531534 (step_size_phi = 0.155\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968699 (should = 1)\n", + " ∫ L(x-w) dA = 1.192261 (should ≈ 1)\n", + " p(x|O_i) = 0.284344\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1556756756756757 (step_size_phi = 0.156\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973199 (should = 1)\n", + " ∫ L(x-w) dA = 1.197800 (should ≈ 1)\n", + " p(x|O_i) = 0.285665\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15603603603603605 (step_size_phi = 0.156\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977710 (should = 1)\n", + " ∫ L(x-w) dA = 1.203352 (should ≈ 1)\n", + " p(x|O_i) = 0.286989\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1563963963963964 (step_size_phi = 0.156\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982231 (should = 1)\n", + " ∫ L(x-w) dA = 1.208917 (should ≈ 1)\n", + " p(x|O_i) = 0.288316\n", + "=======================================================\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15675675675675677 (step_size_phi = 0.157\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986763 (should = 1)\n", + " ∫ L(x-w) dA = 1.214494 (should ≈ 1)\n", + " p(x|O_i) = 0.289646\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15711711711711715 (step_size_phi = 0.157\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963952 (should = 1)\n", + " ∫ L(x-w) dA = 0.728951 (should ≈ 1)\n", + " p(x|O_i) = 0.171959\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1574774774774775 (step_size_phi = 0.157\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968379 (should = 1)\n", + " ∫ L(x-w) dA = 0.732299 (should ≈ 1)\n", + " p(x|O_i) = 0.172748\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15783783783783786 (step_size_phi = 0.158\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972816 (should = 1)\n", + " ∫ L(x-w) dA = 0.735654 (should ≈ 1)\n", + " p(x|O_i) = 0.173540\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15819819819819822 (step_size_phi = 0.158\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977263 (should = 1)\n", + " ∫ L(x-w) dA = 0.739017 (should ≈ 1)\n", + " p(x|O_i) = 0.174333\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15855855855855858 (step_size_phi = 0.159\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981720 (should = 1)\n", + " ∫ L(x-w) dA = 0.742388 (should ≈ 1)\n", + " p(x|O_i) = 0.175128\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15891891891891893 (step_size_phi = 0.159\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986188 (should = 1)\n", + " ∫ L(x-w) dA = 0.745766 (should ≈ 1)\n", + " p(x|O_i) = 0.175925\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1592792792792793 (step_size_phi = 0.159\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965955 (should = 1)\n", + " ∫ L(x-w) dA = 1.216690 (should ≈ 1)\n", + " p(x|O_i) = 0.290105\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.15963963963963965 (step_size_phi = 0.160\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970330 (should = 1)\n", + " ∫ L(x-w) dA = 1.222201 (should ≈ 1)\n", + " p(x|O_i) = 0.291419\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16000000000000003 (step_size_phi = 0.160\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974716 (should = 1)\n", + " ∫ L(x-w) dA = 1.227725 (should ≈ 1)\n", + " p(x|O_i) = 0.292736\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1603603603603604 (step_size_phi = 0.160\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979112 (should = 1)\n", + " ∫ L(x-w) dA = 1.233262 (should ≈ 1)\n", + " p(x|O_i) = 0.294057\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16072072072072074 (step_size_phi = 0.161\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983517 (should = 1)\n", + " ∫ L(x-w) dA = 1.238811 (should ≈ 1)\n", + " p(x|O_i) = 0.295380\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1610810810810811 (step_size_phi = 0.161\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959859 (should = 1)\n", + " ∫ L(x-w) dA = 0.698593 (should ≈ 1)\n", + " p(x|O_i) = 0.164719\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16144144144144146 (step_size_phi = 0.161\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964158 (should = 1)\n", + " ∫ L(x-w) dA = 0.701722 (should ≈ 1)\n", + " p(x|O_i) = 0.165457\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16180180180180181 (step_size_phi = 0.162\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968467 (should = 1)\n", + " ∫ L(x-w) dA = 0.704858 (should ≈ 1)\n", + " p(x|O_i) = 0.166197\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16216216216216217 (step_size_phi = 0.162\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972786 (should = 1)\n", + " ∫ L(x-w) dA = 0.708001 (should ≈ 1)\n", + " p(x|O_i) = 0.166938\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16252252252252256 (step_size_phi = 0.163\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977114 (should = 1)\n", + " ∫ L(x-w) dA = 0.711151 (should ≈ 1)\n", + " p(x|O_i) = 0.167681\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1628828828828829 (step_size_phi = 0.163\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981452 (should = 1)\n", + " ∫ L(x-w) dA = 0.714308 (should ≈ 1)\n", + " p(x|O_i) = 0.168425\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16324324324324327 (step_size_phi = 0.163\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985800 (should = 1)\n", + " ∫ L(x-w) dA = 0.717473 (should ≈ 1)\n", + " p(x|O_i) = 0.169171\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16360360360360363 (step_size_phi = 0.164\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964875 (should = 1)\n", + " ∫ L(x-w) dA = 1.245705 (should ≈ 1)\n", + " p(x|O_i) = 0.296799\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16396396396396398 (step_size_phi = 0.164\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969131 (should = 1)\n", + " ∫ L(x-w) dA = 1.251198 (should ≈ 1)\n", + " p(x|O_i) = 0.298108\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16432432432432434 (step_size_phi = 0.164\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973395 (should = 1)\n", + " ∫ L(x-w) dA = 1.256704 (should ≈ 1)\n", + " p(x|O_i) = 0.299420\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1646846846846847 (step_size_phi = 0.165\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977669 (should = 1)\n", + " ∫ L(x-w) dA = 1.262222 (should ≈ 1)\n", + " p(x|O_i) = 0.300735\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16504504504504508 (step_size_phi = 0.165\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981952 (should = 1)\n", + " ∫ L(x-w) dA = 1.267752 (should ≈ 1)\n", + " p(x|O_i) = 0.302052\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16540540540540544 (step_size_phi = 0.165\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986245 (should = 1)\n", + " ∫ L(x-w) dA = 1.273294 (should ≈ 1)\n", + " p(x|O_i) = 0.303373\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1657657657657658 (step_size_phi = 0.166\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961535 (should = 1)\n", + " ∫ L(x-w) dA = 0.670296 (should ≈ 1)\n", + " p(x|O_i) = 0.157981\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16612612612612615 (step_size_phi = 0.166\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965720 (should = 1)\n", + " ∫ L(x-w) dA = 0.673214 (should ≈ 1)\n", + " p(x|O_i) = 0.158669\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1664864864864865 (step_size_phi = 0.166\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969914 (should = 1)\n", + " ∫ L(x-w) dA = 0.676137 (should ≈ 1)\n", + " p(x|O_i) = 0.159358\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16684684684684686 (step_size_phi = 0.167\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974117 (should = 1)\n", + " ∫ L(x-w) dA = 0.679068 (should ≈ 1)\n", + " p(x|O_i) = 0.160049\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16720720720720725 (step_size_phi = 0.167\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978330 (should = 1)\n", + " ∫ L(x-w) dA = 0.682004 (should ≈ 1)\n", + " p(x|O_i) = 0.160741\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1675675675675676 (step_size_phi = 0.168\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982551 (should = 1)\n", + " ∫ L(x-w) dA = 0.684947 (should ≈ 1)\n", + " p(x|O_i) = 0.161434\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16792792792792796 (step_size_phi = 0.168\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960980 (should = 1)\n", + " ∫ L(x-w) dA = 1.272918 (should ≈ 1)\n", + " p(x|O_i) = 0.302893\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16828828828828832 (step_size_phi = 0.168\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965109 (should = 1)\n", + " ∫ L(x-w) dA = 1.278387 (should ≈ 1)\n", + " p(x|O_i) = 0.304194\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16864864864864867 (step_size_phi = 0.169\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969247 (should = 1)\n", + " ∫ L(x-w) dA = 1.283868 (should ≈ 1)\n", + " p(x|O_i) = 0.305498\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16900900900900903 (step_size_phi = 0.169\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973393 (should = 1)\n", + " ∫ L(x-w) dA = 1.289360 (should ≈ 1)\n", + " p(x|O_i) = 0.306805\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1693693693693694 (step_size_phi = 0.169\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977549 (should = 1)\n", + " ∫ L(x-w) dA = 1.294865 (should ≈ 1)\n", + " p(x|O_i) = 0.308115\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.16972972972972977 (step_size_phi = 0.170\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981713 (should = 1)\n", + " ∫ L(x-w) dA = 1.300381 (should ≈ 1)\n", + " p(x|O_i) = 0.309427\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17009009009009013 (step_size_phi = 0.170\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985886 (should = 1)\n", + " ∫ L(x-w) dA = 1.305908 (should ≈ 1)\n", + " p(x|O_i) = 0.310743\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17045045045045049 (step_size_phi = 0.170\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960146 (should = 1)\n", + " ∫ L(x-w) dA = 0.637674 (should ≈ 1)\n", + " p(x|O_i) = 0.150232\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17081081081081084 (step_size_phi = 0.171\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964210 (should = 1)\n", + " ∫ L(x-w) dA = 0.640373 (should ≈ 1)\n", + " p(x|O_i) = 0.150868\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1711711711711712 (step_size_phi = 0.171\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968282 (should = 1)\n", + " ∫ L(x-w) dA = 0.643078 (should ≈ 1)\n", + " p(x|O_i) = 0.151505\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17153153153153156 (step_size_phi = 0.172\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972364 (should = 1)\n", + " ∫ L(x-w) dA = 0.645788 (should ≈ 1)\n", + " p(x|O_i) = 0.152144\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1718918918918919 (step_size_phi = 0.172\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976454 (should = 1)\n", + " ∫ L(x-w) dA = 0.648505 (should ≈ 1)\n", + " p(x|O_i) = 0.152784\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17225225225225227 (step_size_phi = 0.172\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980552 (should = 1)\n", + " ∫ L(x-w) dA = 0.651227 (should ≈ 1)\n", + " p(x|O_i) = 0.153425\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17261261261261265 (step_size_phi = 0.173\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984659 (should = 1)\n", + " ∫ L(x-w) dA = 0.653954 (should ≈ 1)\n", + " p(x|O_i) = 0.154068\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.172972972972973 (step_size_phi = 0.173\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962285 (should = 1)\n", + " ∫ L(x-w) dA = 1.307861 (should ≈ 1)\n", + " p(x|O_i) = 0.310730\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17333333333333337 (step_size_phi = 0.173\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966299 (should = 1)\n", + " ∫ L(x-w) dA = 1.313316 (should ≈ 1)\n", + " p(x|O_i) = 0.312026\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17369369369369372 (step_size_phi = 0.174\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970321 (should = 1)\n", + " ∫ L(x-w) dA = 1.318783 (should ≈ 1)\n", + " p(x|O_i) = 0.313325\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17405405405405408 (step_size_phi = 0.174\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974351 (should = 1)\n", + " ∫ L(x-w) dA = 1.324261 (should ≈ 1)\n", + " p(x|O_i) = 0.314626\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17441441441441444 (step_size_phi = 0.174\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978390 (should = 1)\n", + " ∫ L(x-w) dA = 1.329750 (should ≈ 1)\n", + " p(x|O_i) = 0.315930\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1747747747747748 (step_size_phi = 0.175\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982437 (should = 1)\n", + " ∫ L(x-w) dA = 1.335250 (should ≈ 1)\n", + " p(x|O_i) = 0.317237\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17513513513513518 (step_size_phi = 0.175\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.986493 (should = 1)\n", + " ∫ L(x-w) dA = 1.340762 (should ≈ 1)\n", + " p(x|O_i) = 0.318547\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17549549549549553 (step_size_phi = 0.175\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959636 (should = 1)\n", + " ∫ L(x-w) dA = 0.603576 (should ≈ 1)\n", + " p(x|O_i) = 0.142126\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1758558558558559 (step_size_phi = 0.176\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963581 (should = 1)\n", + " ∫ L(x-w) dA = 0.606057 (should ≈ 1)\n", + " p(x|O_i) = 0.142710\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17621621621621625 (step_size_phi = 0.176\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967534 (should = 1)\n", + " ∫ L(x-w) dA = 0.608543 (should ≈ 1)\n", + " p(x|O_i) = 0.143296\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1765765765765766 (step_size_phi = 0.177\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971496 (should = 1)\n", + " ∫ L(x-w) dA = 0.611035 (should ≈ 1)\n", + " p(x|O_i) = 0.143883\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17693693693693696 (step_size_phi = 0.177\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975465 (should = 1)\n", + " ∫ L(x-w) dA = 0.613531 (should ≈ 1)\n", + " p(x|O_i) = 0.144470\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17729729729729732 (step_size_phi = 0.177\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979442 (should = 1)\n", + " ∫ L(x-w) dA = 0.616033 (should ≈ 1)\n", + " p(x|O_i) = 0.145059\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17765765765765767 (step_size_phi = 0.178\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983428 (should = 1)\n", + " ∫ L(x-w) dA = 0.618540 (should ≈ 1)\n", + " p(x|O_i) = 0.145650\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17801801801801806 (step_size_phi = 0.178\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960307 (should = 1)\n", + " ∫ L(x-w) dA = 1.337957 (should ≈ 1)\n", + " p(x|O_i) = 0.317521\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17837837837837842 (step_size_phi = 0.178\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964199 (should = 1)\n", + " ∫ L(x-w) dA = 1.343380 (should ≈ 1)\n", + " p(x|O_i) = 0.318808\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17873873873873877 (step_size_phi = 0.179\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968099 (should = 1)\n", + " ∫ L(x-w) dA = 1.348813 (should ≈ 1)\n", + " p(x|O_i) = 0.320098\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17909909909909913 (step_size_phi = 0.179\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972006 (should = 1)\n", + " ∫ L(x-w) dA = 1.354257 (should ≈ 1)\n", + " p(x|O_i) = 0.321390\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17945945945945949 (step_size_phi = 0.179\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975922 (should = 1)\n", + " ∫ L(x-w) dA = 1.359712 (should ≈ 1)\n", + " p(x|O_i) = 0.322684\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.17981981981981984 (step_size_phi = 0.180\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979845 (should = 1)\n", + " ∫ L(x-w) dA = 1.365179 (should ≈ 1)\n", + " p(x|O_i) = 0.323981\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1801801801801802 (step_size_phi = 0.180\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983776 (should = 1)\n", + " ∫ L(x-w) dA = 1.370656 (should ≈ 1)\n", + " p(x|O_i) = 0.325281\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18054054054054058 (step_size_phi = 0.181\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955830 (should = 1)\n", + " ∫ L(x-w) dA = 0.565520 (should ≈ 1)\n", + " p(x|O_i) = 0.133056\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18090090090090094 (step_size_phi = 0.181\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959650 (should = 1)\n", + " ∫ L(x-w) dA = 0.567779 (should ≈ 1)\n", + " p(x|O_i) = 0.133587\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1812612612612613 (step_size_phi = 0.181\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963477 (should = 1)\n", + " ∫ L(x-w) dA = 0.570044 (should ≈ 1)\n", + " p(x|O_i) = 0.134120\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18162162162162165 (step_size_phi = 0.182\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967312 (should = 1)\n", + " ∫ L(x-w) dA = 0.572313 (should ≈ 1)\n", + " p(x|O_i) = 0.134654\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.181981981981982 (step_size_phi = 0.182\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971154 (should = 1)\n", + " ∫ L(x-w) dA = 0.574586 (should ≈ 1)\n", + " p(x|O_i) = 0.135189\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18234234234234237 (step_size_phi = 0.182\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975004 (should = 1)\n", + " ∫ L(x-w) dA = 0.576864 (should ≈ 1)\n", + " p(x|O_i) = 0.135725\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18270270270270272 (step_size_phi = 0.183\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978862 (should = 1)\n", + " ∫ L(x-w) dA = 0.579146 (should ≈ 1)\n", + " p(x|O_i) = 0.136262\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1830630630630631 (step_size_phi = 0.183\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982727 (should = 1)\n", + " ∫ L(x-w) dA = 0.581433 (should ≈ 1)\n", + " p(x|O_i) = 0.136800\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18342342342342347 (step_size_phi = 0.183\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958820 (should = 1)\n", + " ∫ L(x-w) dA = 1.367426 (should ≈ 1)\n", + " p(x|O_i) = 0.324597\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18378378378378382 (step_size_phi = 0.184\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962591 (should = 1)\n", + " ∫ L(x-w) dA = 1.372805 (should ≈ 1)\n", + " p(x|O_i) = 0.325874\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18414414414414418 (step_size_phi = 0.184\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966370 (should = 1)\n", + " ∫ L(x-w) dA = 1.378193 (should ≈ 1)\n", + " p(x|O_i) = 0.327153\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18450450450450454 (step_size_phi = 0.185\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970156 (should = 1)\n", + " ∫ L(x-w) dA = 1.383593 (should ≈ 1)\n", + " p(x|O_i) = 0.328435\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1848648648648649 (step_size_phi = 0.185\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973949 (should = 1)\n", + " ∫ L(x-w) dA = 1.389003 (should ≈ 1)\n", + " p(x|O_i) = 0.329719\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18522522522522525 (step_size_phi = 0.185\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977750 (should = 1)\n", + " ∫ L(x-w) dA = 1.394423 (should ≈ 1)\n", + " p(x|O_i) = 0.331005\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1855855855855856 (step_size_phi = 0.186\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981558 (should = 1)\n", + " ∫ L(x-w) dA = 1.399854 (should ≈ 1)\n", + " p(x|O_i) = 0.332295\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.185945945945946 (step_size_phi = 0.186\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.985374 (should = 1)\n", + " ∫ L(x-w) dA = 1.405296 (should ≈ 1)\n", + " p(x|O_i) = 0.333586\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18630630630630635 (step_size_phi = 0.186\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956132 (should = 1)\n", + " ∫ L(x-w) dA = 0.528066 (should ≈ 1)\n", + " p(x|O_i) = 0.124071\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1866666666666667 (step_size_phi = 0.187\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959835 (should = 1)\n", + " ∫ L(x-w) dA = 0.530110 (should ≈ 1)\n", + " p(x|O_i) = 0.124552\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18702702702702706 (step_size_phi = 0.187\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963544 (should = 1)\n", + " ∫ L(x-w) dA = 0.532159 (should ≈ 1)\n", + " p(x|O_i) = 0.125033\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18738738738738742 (step_size_phi = 0.187\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967261 (should = 1)\n", + " ∫ L(x-w) dA = 0.534212 (should ≈ 1)\n", + " p(x|O_i) = 0.125515\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18774774774774777 (step_size_phi = 0.188\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970984 (should = 1)\n", + " ∫ L(x-w) dA = 0.536268 (should ≈ 1)\n", + " p(x|O_i) = 0.125998\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18810810810810813 (step_size_phi = 0.188\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974715 (should = 1)\n", + " ∫ L(x-w) dA = 0.538329 (should ≈ 1)\n", + " p(x|O_i) = 0.126483\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18846846846846851 (step_size_phi = 0.188\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978454 (should = 1)\n", + " ∫ L(x-w) dA = 0.540394 (should ≈ 1)\n", + " p(x|O_i) = 0.126968\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18882882882882887 (step_size_phi = 0.189\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982199 (should = 1)\n", + " ∫ L(x-w) dA = 0.542462 (should ≈ 1)\n", + " p(x|O_i) = 0.127454\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18918918918918923 (step_size_phi = 0.189\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.957471 (should = 1)\n", + " ∫ L(x-w) dA = 1.396455 (should ≈ 1)\n", + " p(x|O_i) = 0.332379\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18954954954954958 (step_size_phi = 0.190\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961122 (should = 1)\n", + " ∫ L(x-w) dA = 1.401780 (should ≈ 1)\n", + " p(x|O_i) = 0.333647\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.18990990990990994 (step_size_phi = 0.190\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964780 (should = 1)\n", + " ∫ L(x-w) dA = 1.407115 (should ≈ 1)\n", + " p(x|O_i) = 0.334917\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1902702702702703 (step_size_phi = 0.190\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968445 (should = 1)\n", + " ∫ L(x-w) dA = 1.412460 (should ≈ 1)\n", + " p(x|O_i) = 0.336189\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19063063063063065 (step_size_phi = 0.191\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972117 (should = 1)\n", + " ∫ L(x-w) dA = 1.417816 (should ≈ 1)\n", + " p(x|O_i) = 0.337464\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.190990990990991 (step_size_phi = 0.191\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975796 (should = 1)\n", + " ∫ L(x-w) dA = 1.423181 (should ≈ 1)\n", + " p(x|O_i) = 0.338741\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1913513513513514 (step_size_phi = 0.191\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979481 (should = 1)\n", + " ∫ L(x-w) dA = 1.428557 (should ≈ 1)\n", + " p(x|O_i) = 0.340020\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19171171171171175 (step_size_phi = 0.192\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983174 (should = 1)\n", + " ∫ L(x-w) dA = 1.433942 (should ≈ 1)\n", + " p(x|O_i) = 0.341302\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1920720720720721 (step_size_phi = 0.192\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952675 (should = 1)\n", + " ∫ L(x-w) dA = 0.486780 (should ≈ 1)\n", + " p(x|O_i) = 0.114122\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19243243243243247 (step_size_phi = 0.192\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956253 (should = 1)\n", + " ∫ L(x-w) dA = 0.488608 (should ≈ 1)\n", + " p(x|O_i) = 0.114551\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19279279279279282 (step_size_phi = 0.193\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959838 (should = 1)\n", + " ∫ L(x-w) dA = 0.490440 (should ≈ 1)\n", + " p(x|O_i) = 0.114980\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19315315315315318 (step_size_phi = 0.193\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963429 (should = 1)\n", + " ∫ L(x-w) dA = 0.492275 (should ≈ 1)\n", + " p(x|O_i) = 0.115410\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19351351351351354 (step_size_phi = 0.194\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967028 (should = 1)\n", + " ∫ L(x-w) dA = 0.494114 (should ≈ 1)\n", + " p(x|O_i) = 0.115841\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19387387387387392 (step_size_phi = 0.194\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970633 (should = 1)\n", + " ∫ L(x-w) dA = 0.495956 (should ≈ 1)\n", + " p(x|O_i) = 0.116273\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19423423423423428 (step_size_phi = 0.194\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974244 (should = 1)\n", + " ∫ L(x-w) dA = 0.497801 (should ≈ 1)\n", + " p(x|O_i) = 0.116706\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19459459459459463 (step_size_phi = 0.195\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977863 (should = 1)\n", + " ∫ L(x-w) dA = 0.499650 (should ≈ 1)\n", + " p(x|O_i) = 0.117139\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.194954954954955 (step_size_phi = 0.195\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981488 (should = 1)\n", + " ∫ L(x-w) dA = 0.501502 (should ≈ 1)\n", + " p(x|O_i) = 0.117573\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19531531531531535 (step_size_phi = 0.195\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955914 (should = 1)\n", + " ∫ L(x-w) dA = 1.427768 (should ≈ 1)\n", + " p(x|O_i) = 0.341782\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1956756756756757 (step_size_phi = 0.196\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959445 (should = 1)\n", + " ∫ L(x-w) dA = 1.433041 (should ≈ 1)\n", + " p(x|O_i) = 0.343045\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19603603603603606 (step_size_phi = 0.196\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962982 (should = 1)\n", + " ∫ L(x-w) dA = 1.438324 (should ≈ 1)\n", + " p(x|O_i) = 0.344309\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19639639639639642 (step_size_phi = 0.196\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966526 (should = 1)\n", + " ∫ L(x-w) dA = 1.443617 (should ≈ 1)\n", + " p(x|O_i) = 0.345576\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.1967567567567568 (step_size_phi = 0.197\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970076 (should = 1)\n", + " ∫ L(x-w) dA = 1.448920 (should ≈ 1)\n", + " p(x|O_i) = 0.346846\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19711711711711716 (step_size_phi = 0.197\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973633 (should = 1)\n", + " ∫ L(x-w) dA = 1.454232 (should ≈ 1)\n", + " p(x|O_i) = 0.348117\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19747747747747751 (step_size_phi = 0.197\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977196 (should = 1)\n", + " ∫ L(x-w) dA = 1.459554 (should ≈ 1)\n", + " p(x|O_i) = 0.349391\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19783783783783787 (step_size_phi = 0.198\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980765 (should = 1)\n", + " ∫ L(x-w) dA = 1.464886 (should ≈ 1)\n", + " p(x|O_i) = 0.350668\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19819819819819823 (step_size_phi = 0.198\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984342 (should = 1)\n", + " ∫ L(x-w) dA = 1.470227 (should ≈ 1)\n", + " p(x|O_i) = 0.351946\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19855855855855858 (step_size_phi = 0.199\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952376 (should = 1)\n", + " ∫ L(x-w) dA = 0.445478 (should ≈ 1)\n", + " p(x|O_i) = 0.104124\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19891891891891894 (step_size_phi = 0.199\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955836 (should = 1)\n", + " ∫ L(x-w) dA = 0.447096 (should ≈ 1)\n", + " p(x|O_i) = 0.104503\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19927927927927933 (step_size_phi = 0.199\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959303 (should = 1)\n", + " ∫ L(x-w) dA = 0.448717 (should ≈ 1)\n", + " p(x|O_i) = 0.104882\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.19963963963963968 (step_size_phi = 0.200\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962775 (should = 1)\n", + " ∫ L(x-w) dA = 0.450342 (should ≈ 1)\n", + " p(x|O_i) = 0.105261\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20000000000000004 (step_size_phi = 0.200\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966254 (should = 1)\n", + " ∫ L(x-w) dA = 0.451969 (should ≈ 1)\n", + " p(x|O_i) = 0.105642\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2003603603603604 (step_size_phi = 0.200\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969739 (should = 1)\n", + " ∫ L(x-w) dA = 0.453599 (should ≈ 1)\n", + " p(x|O_i) = 0.106023\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20072072072072075 (step_size_phi = 0.201\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973230 (should = 1)\n", + " ∫ L(x-w) dA = 0.455232 (should ≈ 1)\n", + " p(x|O_i) = 0.106404\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2010810810810811 (step_size_phi = 0.201\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976728 (should = 1)\n", + " ∫ L(x-w) dA = 0.456868 (should ≈ 1)\n", + " p(x|O_i) = 0.106787\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20144144144144147 (step_size_phi = 0.201\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980232 (should = 1)\n", + " ∫ L(x-w) dA = 0.458507 (should ≈ 1)\n", + " p(x|O_i) = 0.107170\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20180180180180185 (step_size_phi = 0.202\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953799 (should = 1)\n", + " ∫ L(x-w) dA = 1.467190 (should ≈ 1)\n", + " p(x|O_i) = 0.354112\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2021621621621622 (step_size_phi = 0.202\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.957209 (should = 1)\n", + " ∫ L(x-w) dA = 1.472435 (should ≈ 1)\n", + " p(x|O_i) = 0.355378\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20252252252252256 (step_size_phi = 0.203\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960624 (should = 1)\n", + " ∫ L(x-w) dA = 1.477689 (should ≈ 1)\n", + " p(x|O_i) = 0.356646\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20288288288288292 (step_size_phi = 0.203\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964046 (should = 1)\n", + " ∫ L(x-w) dA = 1.482952 (should ≈ 1)\n", + " p(x|O_i) = 0.357916\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20324324324324328 (step_size_phi = 0.203\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967473 (should = 1)\n", + " ∫ L(x-w) dA = 1.488225 (should ≈ 1)\n", + " p(x|O_i) = 0.359189\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20360360360360363 (step_size_phi = 0.204\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970907 (should = 1)\n", + " ∫ L(x-w) dA = 1.493507 (should ≈ 1)\n", + " p(x|O_i) = 0.360464\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.203963963963964 (step_size_phi = 0.204\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974347 (should = 1)\n", + " ∫ L(x-w) dA = 1.498798 (should ≈ 1)\n", + " p(x|O_i) = 0.361741\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20432432432432435 (step_size_phi = 0.204\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977793 (should = 1)\n", + " ∫ L(x-w) dA = 1.504099 (should ≈ 1)\n", + " p(x|O_i) = 0.363020\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20468468468468473 (step_size_phi = 0.205\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981245 (should = 1)\n", + " ∫ L(x-w) dA = 1.509409 (should ≈ 1)\n", + " p(x|O_i) = 0.364302\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2050450450450451 (step_size_phi = 0.205\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984703 (should = 1)\n", + " ∫ L(x-w) dA = 1.514729 (should ≈ 1)\n", + " p(x|O_i) = 0.365586\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20540540540540544 (step_size_phi = 0.205\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951189 (should = 1)\n", + " ∫ L(x-w) dA = 0.402211 (should ≈ 1)\n", + " p(x|O_i) = 0.093677\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2057657657657658 (step_size_phi = 0.206\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954529 (should = 1)\n", + " ∫ L(x-w) dA = 0.403623 (should ≈ 1)\n", + " p(x|O_i) = 0.094006\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20612612612612616 (step_size_phi = 0.206\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.957875 (should = 1)\n", + " ∫ L(x-w) dA = 0.405038 (should ≈ 1)\n", + " p(x|O_i) = 0.094336\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20648648648648651 (step_size_phi = 0.206\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961227 (should = 1)\n", + " ∫ L(x-w) dA = 0.406455 (should ≈ 1)\n", + " p(x|O_i) = 0.094666\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20684684684684687 (step_size_phi = 0.207\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964585 (should = 1)\n", + " ∫ L(x-w) dA = 0.407875 (should ≈ 1)\n", + " p(x|O_i) = 0.094997\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20720720720720726 (step_size_phi = 0.207\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967949 (should = 1)\n", + " ∫ L(x-w) dA = 0.409298 (should ≈ 1)\n", + " p(x|O_i) = 0.095328\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2075675675675676 (step_size_phi = 0.208\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971319 (should = 1)\n", + " ∫ L(x-w) dA = 0.410723 (should ≈ 1)\n", + " p(x|O_i) = 0.095660\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20792792792792797 (step_size_phi = 0.208\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974695 (should = 1)\n", + " ∫ L(x-w) dA = 0.412150 (should ≈ 1)\n", + " p(x|O_i) = 0.095992\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20828828828828833 (step_size_phi = 0.208\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978076 (should = 1)\n", + " ∫ L(x-w) dA = 0.413580 (should ≈ 1)\n", + " p(x|O_i) = 0.096325\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20864864864864868 (step_size_phi = 0.209\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981463 (should = 1)\n", + " ∫ L(x-w) dA = 0.415012 (should ≈ 1)\n", + " p(x|O_i) = 0.096659\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20900900900900904 (step_size_phi = 0.209\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954072 (should = 1)\n", + " ∫ L(x-w) dA = 1.528126 (should ≈ 1)\n", + " p(x|O_i) = 0.371940\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2093693693693694 (step_size_phi = 0.209\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.957364 (should = 1)\n", + " ∫ L(x-w) dA = 1.533400 (should ≈ 1)\n", + " p(x|O_i) = 0.373224\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.20972972972972975 (step_size_phi = 0.210\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960663 (should = 1)\n", + " ∫ L(x-w) dA = 1.538683 (should ≈ 1)\n", + " p(x|O_i) = 0.374509\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21009009009009014 (step_size_phi = 0.210\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963967 (should = 1)\n", + " ∫ L(x-w) dA = 1.543976 (should ≈ 1)\n", + " p(x|O_i) = 0.375798\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2104504504504505 (step_size_phi = 0.210\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967277 (should = 1)\n", + " ∫ L(x-w) dA = 1.549277 (should ≈ 1)\n", + " p(x|O_i) = 0.377088\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21081081081081085 (step_size_phi = 0.211\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970592 (should = 1)\n", + " ∫ L(x-w) dA = 1.554587 (should ≈ 1)\n", + " p(x|O_i) = 0.378380\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2111711711711712 (step_size_phi = 0.211\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973913 (should = 1)\n", + " ∫ L(x-w) dA = 1.559906 (should ≈ 1)\n", + " p(x|O_i) = 0.379675\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21153153153153156 (step_size_phi = 0.212\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977240 (should = 1)\n", + " ∫ L(x-w) dA = 1.565235 (should ≈ 1)\n", + " p(x|O_i) = 0.380972\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21189189189189192 (step_size_phi = 0.212\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980572 (should = 1)\n", + " ∫ L(x-w) dA = 1.570572 (should ≈ 1)\n", + " p(x|O_i) = 0.382271\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21225225225225228 (step_size_phi = 0.212\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983910 (should = 1)\n", + " ∫ L(x-w) dA = 1.575919 (should ≈ 1)\n", + " p(x|O_i) = 0.383572\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21261261261261266 (step_size_phi = 0.213\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948761 (should = 1)\n", + " ∫ L(x-w) dA = 0.357312 (should ≈ 1)\n", + " p(x|O_i) = 0.082941\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21297297297297302 (step_size_phi = 0.213\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951980 (should = 1)\n", + " ∫ L(x-w) dA = 0.358525 (should ≈ 1)\n", + " p(x|O_i) = 0.083223\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21333333333333337 (step_size_phi = 0.213\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955205 (should = 1)\n", + " ∫ L(x-w) dA = 0.359739 (should ≈ 1)\n", + " p(x|O_i) = 0.083504\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21369369369369373 (step_size_phi = 0.214\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958434 (should = 1)\n", + " ∫ L(x-w) dA = 0.360955 (should ≈ 1)\n", + " p(x|O_i) = 0.083787\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2140540540540541 (step_size_phi = 0.214\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961669 (should = 1)\n", + " ∫ L(x-w) dA = 0.362174 (should ≈ 1)\n", + " p(x|O_i) = 0.084070\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21441441441441444 (step_size_phi = 0.214\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964910 (should = 1)\n", + " ∫ L(x-w) dA = 0.363394 (should ≈ 1)\n", + " p(x|O_i) = 0.084353\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2147747747747748 (step_size_phi = 0.215\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968156 (should = 1)\n", + " ∫ L(x-w) dA = 0.364617 (should ≈ 1)\n", + " p(x|O_i) = 0.084637\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21513513513513516 (step_size_phi = 0.215\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971408 (should = 1)\n", + " ∫ L(x-w) dA = 0.365841 (should ≈ 1)\n", + " p(x|O_i) = 0.084921\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21549549549549554 (step_size_phi = 0.215\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974665 (should = 1)\n", + " ∫ L(x-w) dA = 0.367068 (should ≈ 1)\n", + " p(x|O_i) = 0.085206\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2158558558558559 (step_size_phi = 0.216\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977927 (should = 1)\n", + " ∫ L(x-w) dA = 0.368297 (should ≈ 1)\n", + " p(x|O_i) = 0.085491\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21621621621621626 (step_size_phi = 0.216\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949690 (should = 1)\n", + " ∫ L(x-w) dA = 1.607773 (should ≈ 1)\n", + " p(x|O_i) = 0.393257\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2165765765765766 (step_size_phi = 0.217\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952858 (should = 1)\n", + " ∫ L(x-w) dA = 1.613137 (should ≈ 1)\n", + " p(x|O_i) = 0.394569\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21693693693693697 (step_size_phi = 0.217\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956031 (should = 1)\n", + " ∫ L(x-w) dA = 1.618510 (should ≈ 1)\n", + " p(x|O_i) = 0.395883\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21729729729729733 (step_size_phi = 0.217\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959210 (should = 1)\n", + " ∫ L(x-w) dA = 1.623891 (should ≈ 1)\n", + " p(x|O_i) = 0.397200\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21765765765765768 (step_size_phi = 0.218\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962394 (should = 1)\n", + " ∫ L(x-w) dA = 1.629282 (should ≈ 1)\n", + " p(x|O_i) = 0.398518\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21801801801801807 (step_size_phi = 0.218\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965584 (should = 1)\n", + " ∫ L(x-w) dA = 1.634681 (should ≈ 1)\n", + " p(x|O_i) = 0.399839\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21837837837837842 (step_size_phi = 0.218\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968778 (should = 1)\n", + " ∫ L(x-w) dA = 1.640090 (should ≈ 1)\n", + " p(x|O_i) = 0.401162\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21873873873873878 (step_size_phi = 0.219\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971978 (should = 1)\n", + " ∫ L(x-w) dA = 1.645507 (should ≈ 1)\n", + " p(x|O_i) = 0.402487\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21909909909909914 (step_size_phi = 0.219\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975183 (should = 1)\n", + " ∫ L(x-w) dA = 1.650933 (should ≈ 1)\n", + " p(x|O_i) = 0.403814\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2194594594594595 (step_size_phi = 0.219\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978394 (should = 1)\n", + " ∫ L(x-w) dA = 1.656368 (should ≈ 1)\n", + " p(x|O_i) = 0.405144\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.21981981981981985 (step_size_phi = 0.220\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981610 (should = 1)\n", + " ∫ L(x-w) dA = 1.661813 (should ≈ 1)\n", + " p(x|O_i) = 0.406475\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2201801801801802 (step_size_phi = 0.220\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.984831 (should = 1)\n", + " ∫ L(x-w) dA = 1.667266 (should ≈ 1)\n", + " p(x|O_i) = 0.407809\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2205405405405406 (step_size_phi = 0.221\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947847 (should = 1)\n", + " ∫ L(x-w) dA = 0.312459 (should ≈ 1)\n", + " p(x|O_i) = 0.072384\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22090090090090095 (step_size_phi = 0.221\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950947 (should = 1)\n", + " ∫ L(x-w) dA = 0.313481 (should ≈ 1)\n", + " p(x|O_i) = 0.072621\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2212612612612613 (step_size_phi = 0.221\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954052 (should = 1)\n", + " ∫ L(x-w) dA = 0.314505 (should ≈ 1)\n", + " p(x|O_i) = 0.072858\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22162162162162166 (step_size_phi = 0.222\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.957162 (should = 1)\n", + " ∫ L(x-w) dA = 0.315530 (should ≈ 1)\n", + " p(x|O_i) = 0.073095\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22198198198198202 (step_size_phi = 0.222\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960278 (should = 1)\n", + " ∫ L(x-w) dA = 0.316557 (should ≈ 1)\n", + " p(x|O_i) = 0.073333\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22234234234234238 (step_size_phi = 0.222\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963398 (should = 1)\n", + " ∫ L(x-w) dA = 0.317586 (should ≈ 1)\n", + " p(x|O_i) = 0.073571\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22270270270270273 (step_size_phi = 0.223\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966523 (should = 1)\n", + " ∫ L(x-w) dA = 0.318616 (should ≈ 1)\n", + " p(x|O_i) = 0.073810\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2230630630630631 (step_size_phi = 0.223\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969654 (should = 1)\n", + " ∫ L(x-w) dA = 0.319648 (should ≈ 1)\n", + " p(x|O_i) = 0.074049\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22342342342342347 (step_size_phi = 0.223\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972789 (should = 1)\n", + " ∫ L(x-w) dA = 0.320682 (should ≈ 1)\n", + " p(x|O_i) = 0.074289\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22378378378378383 (step_size_phi = 0.224\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975930 (should = 1)\n", + " ∫ L(x-w) dA = 0.321717 (should ≈ 1)\n", + " p(x|O_i) = 0.074528\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2241441441441442 (step_size_phi = 0.224\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979075 (should = 1)\n", + " ∫ L(x-w) dA = 0.322754 (should ≈ 1)\n", + " p(x|O_i) = 0.074769\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22450450450450454 (step_size_phi = 0.225\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949814 (should = 1)\n", + " ∫ L(x-w) dA = 1.724738 (should ≈ 1)\n", + " p(x|O_i) = 0.420844\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2248648648648649 (step_size_phi = 0.225\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952866 (should = 1)\n", + " ∫ L(x-w) dA = 1.730279 (should ≈ 1)\n", + " p(x|O_i) = 0.422196\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22522522522522526 (step_size_phi = 0.225\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955922 (should = 1)\n", + " ∫ L(x-w) dA = 1.735829 (should ≈ 1)\n", + " p(x|O_i) = 0.423550\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2255855855855856 (step_size_phi = 0.226\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958984 (should = 1)\n", + " ∫ L(x-w) dA = 1.741389 (should ≈ 1)\n", + " p(x|O_i) = 0.424907\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.225945945945946 (step_size_phi = 0.226\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962050 (should = 1)\n", + " ∫ L(x-w) dA = 1.746957 (should ≈ 1)\n", + " p(x|O_i) = 0.426265\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22630630630630635 (step_size_phi = 0.226\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965121 (should = 1)\n", + " ∫ L(x-w) dA = 1.752533 (should ≈ 1)\n", + " p(x|O_i) = 0.427626\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2266666666666667 (step_size_phi = 0.227\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968197 (should = 1)\n", + " ∫ L(x-w) dA = 1.758119 (should ≈ 1)\n", + " p(x|O_i) = 0.428989\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22702702702702707 (step_size_phi = 0.227\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971278 (should = 1)\n", + " ∫ L(x-w) dA = 1.763714 (should ≈ 1)\n", + " p(x|O_i) = 0.430354\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22738738738738742 (step_size_phi = 0.227\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974364 (should = 1)\n", + " ∫ L(x-w) dA = 1.769317 (should ≈ 1)\n", + " p(x|O_i) = 0.431722\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22774774774774778 (step_size_phi = 0.228\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977455 (should = 1)\n", + " ∫ L(x-w) dA = 1.774930 (should ≈ 1)\n", + " p(x|O_i) = 0.433091\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22810810810810814 (step_size_phi = 0.228\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980550 (should = 1)\n", + " ∫ L(x-w) dA = 1.780551 (should ≈ 1)\n", + " p(x|O_i) = 0.434463\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2284684684684685 (step_size_phi = 0.228\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983651 (should = 1)\n", + " ∫ L(x-w) dA = 1.786181 (should ≈ 1)\n", + " p(x|O_i) = 0.435837\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22882882882882888 (step_size_phi = 0.229\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944757 (should = 1)\n", + " ∫ L(x-w) dA = 0.267262 (should ≈ 1)\n", + " p(x|O_i) = 0.061953\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22918918918918924 (step_size_phi = 0.229\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947735 (should = 1)\n", + " ∫ L(x-w) dA = 0.268105 (should ≈ 1)\n", + " p(x|O_i) = 0.062148\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2295495495495496 (step_size_phi = 0.230\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950718 (should = 1)\n", + " ∫ L(x-w) dA = 0.268949 (should ≈ 1)\n", + " p(x|O_i) = 0.062344\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.22990990990990995 (step_size_phi = 0.230\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953705 (should = 1)\n", + " ∫ L(x-w) dA = 0.269794 (should ≈ 1)\n", + " p(x|O_i) = 0.062540\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2302702702702703 (step_size_phi = 0.230\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956697 (should = 1)\n", + " ∫ L(x-w) dA = 0.270640 (should ≈ 1)\n", + " p(x|O_i) = 0.062736\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23063063063063066 (step_size_phi = 0.231\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959694 (should = 1)\n", + " ∫ L(x-w) dA = 0.271488 (should ≈ 1)\n", + " p(x|O_i) = 0.062932\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23099099099099102 (step_size_phi = 0.231\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962695 (should = 1)\n", + " ∫ L(x-w) dA = 0.272337 (should ≈ 1)\n", + " p(x|O_i) = 0.063129\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2313513513513514 (step_size_phi = 0.231\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965701 (should = 1)\n", + " ∫ L(x-w) dA = 0.273187 (should ≈ 1)\n", + " p(x|O_i) = 0.063326\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23171171171171176 (step_size_phi = 0.232\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968712 (should = 1)\n", + " ∫ L(x-w) dA = 0.274039 (should ≈ 1)\n", + " p(x|O_i) = 0.063524\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23207207207207212 (step_size_phi = 0.232\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971728 (should = 1)\n", + " ∫ L(x-w) dA = 0.274892 (should ≈ 1)\n", + " p(x|O_i) = 0.063721\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23243243243243247 (step_size_phi = 0.232\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974748 (should = 1)\n", + " ∫ L(x-w) dA = 0.275746 (should ≈ 1)\n", + " p(x|O_i) = 0.063920\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23279279279279283 (step_size_phi = 0.233\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977772 (should = 1)\n", + " ∫ L(x-w) dA = 0.276602 (should ≈ 1)\n", + " p(x|O_i) = 0.064118\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2331531531531532 (step_size_phi = 0.233\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947535 (should = 1)\n", + " ∫ L(x-w) dA = 1.860125 (should ≈ 1)\n", + " p(x|O_i) = 0.448480\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23351351351351354 (step_size_phi = 0.234\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950467 (should = 1)\n", + " ∫ L(x-w) dA = 1.865880 (should ≈ 1)\n", + " p(x|O_i) = 0.449868\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23387387387387393 (step_size_phi = 0.234\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953403 (should = 1)\n", + " ∫ L(x-w) dA = 1.871643 (should ≈ 1)\n", + " p(x|O_i) = 0.451257\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23423423423423428 (step_size_phi = 0.234\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956343 (should = 1)\n", + " ∫ L(x-w) dA = 1.877415 (should ≈ 1)\n", + " p(x|O_i) = 0.452649\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23459459459459464 (step_size_phi = 0.235\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959288 (should = 1)\n", + " ∫ L(x-w) dA = 1.883196 (should ≈ 1)\n", + " p(x|O_i) = 0.454043\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.234954954954955 (step_size_phi = 0.235\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962237 (should = 1)\n", + " ∫ L(x-w) dA = 1.888986 (should ≈ 1)\n", + " p(x|O_i) = 0.455439\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23531531531531535 (step_size_phi = 0.235\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965191 (should = 1)\n", + " ∫ L(x-w) dA = 1.894785 (should ≈ 1)\n", + " p(x|O_i) = 0.456837\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2356756756756757 (step_size_phi = 0.236\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968149 (should = 1)\n", + " ∫ L(x-w) dA = 1.900593 (should ≈ 1)\n", + " p(x|O_i) = 0.458237\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23603603603603607 (step_size_phi = 0.236\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971112 (should = 1)\n", + " ∫ L(x-w) dA = 1.906410 (should ≈ 1)\n", + " p(x|O_i) = 0.459640\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23639639639639642 (step_size_phi = 0.236\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974080 (should = 1)\n", + " ∫ L(x-w) dA = 1.912235 (should ≈ 1)\n", + " p(x|O_i) = 0.461044\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2367567567567568 (step_size_phi = 0.237\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977052 (should = 1)\n", + " ∫ L(x-w) dA = 1.918070 (should ≈ 1)\n", + " p(x|O_i) = 0.462451\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23711711711711717 (step_size_phi = 0.237\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980029 (should = 1)\n", + " ∫ L(x-w) dA = 1.923913 (should ≈ 1)\n", + " p(x|O_i) = 0.463860\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23747747747747752 (step_size_phi = 0.237\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983010 (should = 1)\n", + " ∫ L(x-w) dA = 1.929765 (should ≈ 1)\n", + " p(x|O_i) = 0.465271\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23783783783783788 (step_size_phi = 0.238\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942002 (should = 1)\n", + " ∫ L(x-w) dA = 0.223675 (should ≈ 1)\n", + " p(x|O_i) = 0.052066\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23819819819819824 (step_size_phi = 0.238\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944859 (should = 1)\n", + " ∫ L(x-w) dA = 0.224354 (should ≈ 1)\n", + " p(x|O_i) = 0.052224\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2385585585585586 (step_size_phi = 0.239\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947720 (should = 1)\n", + " ∫ L(x-w) dA = 0.225033 (should ≈ 1)\n", + " p(x|O_i) = 0.052382\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23891891891891895 (step_size_phi = 0.239\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950585 (should = 1)\n", + " ∫ L(x-w) dA = 0.225713 (should ≈ 1)\n", + " p(x|O_i) = 0.052541\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.23927927927927933 (step_size_phi = 0.239\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953455 (should = 1)\n", + " ∫ L(x-w) dA = 0.226395 (should ≈ 1)\n", + " p(x|O_i) = 0.052699\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2396396396396397 (step_size_phi = 0.240\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956329 (should = 1)\n", + " ∫ L(x-w) dA = 0.227077 (should ≈ 1)\n", + " p(x|O_i) = 0.052858\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24000000000000005 (step_size_phi = 0.240\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959207 (should = 1)\n", + " ∫ L(x-w) dA = 0.227761 (should ≈ 1)\n", + " p(x|O_i) = 0.053017\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2403603603603604 (step_size_phi = 0.240\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962090 (should = 1)\n", + " ∫ L(x-w) dA = 0.228445 (should ≈ 1)\n", + " p(x|O_i) = 0.053177\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24072072072072076 (step_size_phi = 0.241\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964977 (should = 1)\n", + " ∫ L(x-w) dA = 0.229131 (should ≈ 1)\n", + " p(x|O_i) = 0.053336\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24108108108108112 (step_size_phi = 0.241\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967868 (should = 1)\n", + " ∫ L(x-w) dA = 0.229817 (should ≈ 1)\n", + " p(x|O_i) = 0.053496\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24144144144144147 (step_size_phi = 0.241\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970764 (should = 1)\n", + " ∫ L(x-w) dA = 0.230505 (should ≈ 1)\n", + " p(x|O_i) = 0.053656\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24180180180180183 (step_size_phi = 0.242\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973664 (should = 1)\n", + " ∫ L(x-w) dA = 0.231193 (should ≈ 1)\n", + " p(x|O_i) = 0.053816\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24216216216216221 (step_size_phi = 0.242\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976568 (should = 1)\n", + " ∫ L(x-w) dA = 0.231883 (should ≈ 1)\n", + " p(x|O_i) = 0.053977\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24252252252252257 (step_size_phi = 0.243\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.945332 (should = 1)\n", + " ∫ L(x-w) dA = 1.996253 (should ≈ 1)\n", + " p(x|O_i) = 0.471265\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24288288288288293 (step_size_phi = 0.243\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948143 (should = 1)\n", + " ∫ L(x-w) dA = 2.002190 (should ≈ 1)\n", + " p(x|O_i) = 0.472667\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24324324324324328 (step_size_phi = 0.243\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950959 (should = 1)\n", + " ∫ L(x-w) dA = 2.008135 (should ≈ 1)\n", + " p(x|O_i) = 0.474070\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24360360360360364 (step_size_phi = 0.244\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953778 (should = 1)\n", + " ∫ L(x-w) dA = 2.014090 (should ≈ 1)\n", + " p(x|O_i) = 0.475476\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.243963963963964 (step_size_phi = 0.244\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956602 (should = 1)\n", + " ∫ L(x-w) dA = 2.020053 (should ≈ 1)\n", + " p(x|O_i) = 0.476884\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24432432432432435 (step_size_phi = 0.244\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959430 (should = 1)\n", + " ∫ L(x-w) dA = 2.026025 (should ≈ 1)\n", + " p(x|O_i) = 0.478294\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24468468468468474 (step_size_phi = 0.245\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962263 (should = 1)\n", + " ∫ L(x-w) dA = 2.032006 (should ≈ 1)\n", + " p(x|O_i) = 0.479706\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2450450450450451 (step_size_phi = 0.245\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965099 (should = 1)\n", + " ∫ L(x-w) dA = 2.037996 (should ≈ 1)\n", + " p(x|O_i) = 0.481120\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24540540540540545 (step_size_phi = 0.245\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967940 (should = 1)\n", + " ∫ L(x-w) dA = 2.043994 (should ≈ 1)\n", + " p(x|O_i) = 0.482536\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2457657657657658 (step_size_phi = 0.246\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970784 (should = 1)\n", + " ∫ L(x-w) dA = 2.050002 (should ≈ 1)\n", + " p(x|O_i) = 0.483954\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24612612612612617 (step_size_phi = 0.246\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973633 (should = 1)\n", + " ∫ L(x-w) dA = 2.056018 (should ≈ 1)\n", + " p(x|O_i) = 0.485374\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24648648648648652 (step_size_phi = 0.246\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976487 (should = 1)\n", + " ∫ L(x-w) dA = 2.062043 (should ≈ 1)\n", + " p(x|O_i) = 0.486797\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24684684684684688 (step_size_phi = 0.247\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979344 (should = 1)\n", + " ∫ L(x-w) dA = 2.068077 (should ≈ 1)\n", + " p(x|O_i) = 0.488221\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24720720720720724 (step_size_phi = 0.247\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982205 (should = 1)\n", + " ∫ L(x-w) dA = 2.074119 (should ≈ 1)\n", + " p(x|O_i) = 0.489647\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24756756756756762 (step_size_phi = 0.248\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.938877 (should = 1)\n", + " ∫ L(x-w) dA = 0.182594 (should ≈ 1)\n", + " p(x|O_i) = 0.042822\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24792792792792798 (step_size_phi = 0.248\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.941612 (should = 1)\n", + " ∫ L(x-w) dA = 0.183126 (should ≈ 1)\n", + " p(x|O_i) = 0.042947\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24828828828828833 (step_size_phi = 0.248\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944352 (should = 1)\n", + " ∫ L(x-w) dA = 0.183658 (should ≈ 1)\n", + " p(x|O_i) = 0.043072\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2486486486486487 (step_size_phi = 0.249\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947095 (should = 1)\n", + " ∫ L(x-w) dA = 0.184192 (should ≈ 1)\n", + " p(x|O_i) = 0.043197\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24900900900900905 (step_size_phi = 0.249\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949842 (should = 1)\n", + " ∫ L(x-w) dA = 0.184726 (should ≈ 1)\n", + " p(x|O_i) = 0.043322\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2493693693693694 (step_size_phi = 0.249\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952593 (should = 1)\n", + " ∫ L(x-w) dA = 0.185261 (should ≈ 1)\n", + " p(x|O_i) = 0.043448\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.24972972972972976 (step_size_phi = 0.250\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955348 (should = 1)\n", + " ∫ L(x-w) dA = 0.185797 (should ≈ 1)\n", + " p(x|O_i) = 0.043573\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25009009009009014 (step_size_phi = 0.250\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958107 (should = 1)\n", + " ∫ L(x-w) dA = 0.186334 (should ≈ 1)\n", + " p(x|O_i) = 0.043699\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2504504504504505 (step_size_phi = 0.250\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960871 (should = 1)\n", + " ∫ L(x-w) dA = 0.186871 (should ≈ 1)\n", + " p(x|O_i) = 0.043825\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25081081081081086 (step_size_phi = 0.251\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963638 (should = 1)\n", + " ∫ L(x-w) dA = 0.187409 (should ≈ 1)\n", + " p(x|O_i) = 0.043951\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2511711711711712 (step_size_phi = 0.251\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966409 (should = 1)\n", + " ∫ L(x-w) dA = 0.187948 (should ≈ 1)\n", + " p(x|O_i) = 0.044078\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25153153153153157 (step_size_phi = 0.252\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969184 (should = 1)\n", + " ∫ L(x-w) dA = 0.188488 (should ≈ 1)\n", + " p(x|O_i) = 0.044204\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25189189189189193 (step_size_phi = 0.252\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971963 (should = 1)\n", + " ∫ L(x-w) dA = 0.189028 (should ≈ 1)\n", + " p(x|O_i) = 0.044331\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2522522522522523 (step_size_phi = 0.252\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974746 (should = 1)\n", + " ∫ L(x-w) dA = 0.189569 (should ≈ 1)\n", + " p(x|O_i) = 0.044458\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25261261261261264 (step_size_phi = 0.253\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977533 (should = 1)\n", + " ∫ L(x-w) dA = 0.190111 (should ≈ 1)\n", + " p(x|O_i) = 0.044585\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.252972972972973 (step_size_phi = 0.253\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.945209 (should = 1)\n", + " ∫ L(x-w) dA = 2.101549 (should ≈ 1)\n", + " p(x|O_i) = 0.482740\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25333333333333335 (step_size_phi = 0.253\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947903 (should = 1)\n", + " ∫ L(x-w) dA = 2.107540 (should ≈ 1)\n", + " p(x|O_i) = 0.484117\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2536936936936937 (step_size_phi = 0.254\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950602 (should = 1)\n", + " ∫ L(x-w) dA = 2.113540 (should ≈ 1)\n", + " p(x|O_i) = 0.485495\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25405405405405407 (step_size_phi = 0.254\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953305 (should = 1)\n", + " ∫ L(x-w) dA = 2.119549 (should ≈ 1)\n", + " p(x|O_i) = 0.486875\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2544144144144144 (step_size_phi = 0.254\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956011 (should = 1)\n", + " ∫ L(x-w) dA = 2.125566 (should ≈ 1)\n", + " p(x|O_i) = 0.488257\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2547747747747748 (step_size_phi = 0.255\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958721 (should = 1)\n", + " ∫ L(x-w) dA = 2.131592 (should ≈ 1)\n", + " p(x|O_i) = 0.489641\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25513513513513514 (step_size_phi = 0.255\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961435 (should = 1)\n", + " ∫ L(x-w) dA = 2.137626 (should ≈ 1)\n", + " p(x|O_i) = 0.491028\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25549549549549555 (step_size_phi = 0.255\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964153 (should = 1)\n", + " ∫ L(x-w) dA = 2.143669 (should ≈ 1)\n", + " p(x|O_i) = 0.492416\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2558558558558559 (step_size_phi = 0.256\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966875 (should = 1)\n", + " ∫ L(x-w) dA = 2.149720 (should ≈ 1)\n", + " p(x|O_i) = 0.493806\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25621621621621626 (step_size_phi = 0.256\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969600 (should = 1)\n", + " ∫ L(x-w) dA = 2.155780 (should ≈ 1)\n", + " p(x|O_i) = 0.495198\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2565765765765766 (step_size_phi = 0.257\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972329 (should = 1)\n", + " ∫ L(x-w) dA = 2.161848 (should ≈ 1)\n", + " p(x|O_i) = 0.496592\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.256936936936937 (step_size_phi = 0.257\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975063 (should = 1)\n", + " ∫ L(x-w) dA = 2.167925 (should ≈ 1)\n", + " p(x|O_i) = 0.497987\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25729729729729733 (step_size_phi = 0.257\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977800 (should = 1)\n", + " ∫ L(x-w) dA = 2.174011 (should ≈ 1)\n", + " p(x|O_i) = 0.499385\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2576576576576577 (step_size_phi = 0.258\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980540 (should = 1)\n", + " ∫ L(x-w) dA = 2.180105 (should ≈ 1)\n", + " p(x|O_i) = 0.500785\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25801801801801805 (step_size_phi = 0.258\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983285 (should = 1)\n", + " ∫ L(x-w) dA = 2.186207 (should ≈ 1)\n", + " p(x|O_i) = 0.502187\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2583783783783784 (step_size_phi = 0.258\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.937301 (should = 1)\n", + " ∫ L(x-w) dA = 0.145266 (should ≈ 1)\n", + " p(x|O_i) = 0.034365\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25873873873873876 (step_size_phi = 0.259\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939917 (should = 1)\n", + " ∫ L(x-w) dA = 0.145671 (should ≈ 1)\n", + " p(x|O_i) = 0.034461\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2590990990990991 (step_size_phi = 0.259\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942537 (should = 1)\n", + " ∫ L(x-w) dA = 0.146077 (should ≈ 1)\n", + " p(x|O_i) = 0.034557\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2594594594594595 (step_size_phi = 0.259\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.945161 (should = 1)\n", + " ∫ L(x-w) dA = 0.146484 (should ≈ 1)\n", + " p(x|O_i) = 0.034653\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.25981981981981983 (step_size_phi = 0.260\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947788 (should = 1)\n", + " ∫ L(x-w) dA = 0.146891 (should ≈ 1)\n", + " p(x|O_i) = 0.034750\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2601801801801802 (step_size_phi = 0.260\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950419 (should = 1)\n", + " ∫ L(x-w) dA = 0.147299 (should ≈ 1)\n", + " p(x|O_i) = 0.034846\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26054054054054054 (step_size_phi = 0.261\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953054 (should = 1)\n", + " ∫ L(x-w) dA = 0.147707 (should ≈ 1)\n", + " p(x|O_i) = 0.034943\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26090090090090096 (step_size_phi = 0.261\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955692 (should = 1)\n", + " ∫ L(x-w) dA = 0.148116 (should ≈ 1)\n", + " p(x|O_i) = 0.035039\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2612612612612613 (step_size_phi = 0.261\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958334 (should = 1)\n", + " ∫ L(x-w) dA = 0.148526 (should ≈ 1)\n", + " p(x|O_i) = 0.035136\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26162162162162167 (step_size_phi = 0.262\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960979 (should = 1)\n", + " ∫ L(x-w) dA = 0.148936 (should ≈ 1)\n", + " p(x|O_i) = 0.035233\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.261981981981982 (step_size_phi = 0.262\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963628 (should = 1)\n", + " ∫ L(x-w) dA = 0.149346 (should ≈ 1)\n", + " p(x|O_i) = 0.035330\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2623423423423424 (step_size_phi = 0.262\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966281 (should = 1)\n", + " ∫ L(x-w) dA = 0.149757 (should ≈ 1)\n", + " p(x|O_i) = 0.035428\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26270270270270274 (step_size_phi = 0.263\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968938 (should = 1)\n", + " ∫ L(x-w) dA = 0.150169 (should ≈ 1)\n", + " p(x|O_i) = 0.035525\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2630630630630631 (step_size_phi = 0.263\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971598 (should = 1)\n", + " ∫ L(x-w) dA = 0.150581 (should ≈ 1)\n", + " p(x|O_i) = 0.035623\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26342342342342345 (step_size_phi = 0.263\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974261 (should = 1)\n", + " ∫ L(x-w) dA = 0.150994 (should ≈ 1)\n", + " p(x|O_i) = 0.035720\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2637837837837838 (step_size_phi = 0.264\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.940982 (should = 1)\n", + " ∫ L(x-w) dA = 2.120286 (should ≈ 1)\n", + " p(x|O_i) = 0.473215\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26414414414414417 (step_size_phi = 0.264\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.943555 (should = 1)\n", + " ∫ L(x-w) dA = 2.126084 (should ≈ 1)\n", + " p(x|O_i) = 0.474509\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2645045045045045 (step_size_phi = 0.265\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946131 (should = 1)\n", + " ∫ L(x-w) dA = 2.131889 (should ≈ 1)\n", + " p(x|O_i) = 0.475804\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2648648648648649 (step_size_phi = 0.265\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948711 (should = 1)\n", + " ∫ L(x-w) dA = 2.137701 (should ≈ 1)\n", + " p(x|O_i) = 0.477102\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26522522522522524 (step_size_phi = 0.265\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951294 (should = 1)\n", + " ∫ L(x-w) dA = 2.143522 (should ≈ 1)\n", + " p(x|O_i) = 0.478401\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2655855855855856 (step_size_phi = 0.266\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953881 (should = 1)\n", + " ∫ L(x-w) dA = 2.149351 (should ≈ 1)\n", + " p(x|O_i) = 0.479702\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26594594594594595 (step_size_phi = 0.266\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956471 (should = 1)\n", + " ∫ L(x-w) dA = 2.155188 (should ≈ 1)\n", + " p(x|O_i) = 0.481004\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26630630630630636 (step_size_phi = 0.266\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959065 (should = 1)\n", + " ∫ L(x-w) dA = 2.161032 (should ≈ 1)\n", + " p(x|O_i) = 0.482309\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2666666666666667 (step_size_phi = 0.267\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961662 (should = 1)\n", + " ∫ L(x-w) dA = 2.166885 (should ≈ 1)\n", + " p(x|O_i) = 0.483615\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2670270270270271 (step_size_phi = 0.267\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964263 (should = 1)\n", + " ∫ L(x-w) dA = 2.172745 (should ≈ 1)\n", + " p(x|O_i) = 0.484923\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26738738738738743 (step_size_phi = 0.267\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966867 (should = 1)\n", + " ∫ L(x-w) dA = 2.178613 (should ≈ 1)\n", + " p(x|O_i) = 0.486233\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2677477477477478 (step_size_phi = 0.268\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969475 (should = 1)\n", + " ∫ L(x-w) dA = 2.184490 (should ≈ 1)\n", + " p(x|O_i) = 0.487544\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26810810810810815 (step_size_phi = 0.268\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972087 (should = 1)\n", + " ∫ L(x-w) dA = 2.190374 (should ≈ 1)\n", + " p(x|O_i) = 0.488857\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2684684684684685 (step_size_phi = 0.268\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974702 (should = 1)\n", + " ∫ L(x-w) dA = 2.196266 (should ≈ 1)\n", + " p(x|O_i) = 0.490172\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26882882882882886 (step_size_phi = 0.269\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977320 (should = 1)\n", + " ∫ L(x-w) dA = 2.202166 (should ≈ 1)\n", + " p(x|O_i) = 0.491489\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2691891891891892 (step_size_phi = 0.269\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979942 (should = 1)\n", + " ∫ L(x-w) dA = 2.208074 (should ≈ 1)\n", + " p(x|O_i) = 0.492808\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26954954954954957 (step_size_phi = 0.270\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982567 (should = 1)\n", + " ∫ L(x-w) dA = 2.213990 (should ≈ 1)\n", + " p(x|O_i) = 0.494128\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.26990990990990993 (step_size_phi = 0.270\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.933717 (should = 1)\n", + " ∫ L(x-w) dA = 0.111703 (should ≈ 1)\n", + " p(x|O_i) = 0.026582\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2702702702702703 (step_size_phi = 0.270\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.936212 (should = 1)\n", + " ∫ L(x-w) dA = 0.112002 (should ≈ 1)\n", + " p(x|O_i) = 0.026653\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27063063063063064 (step_size_phi = 0.271\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.938710 (should = 1)\n", + " ∫ L(x-w) dA = 0.112301 (should ≈ 1)\n", + " p(x|O_i) = 0.026724\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.270990990990991 (step_size_phi = 0.271\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.941212 (should = 1)\n", + " ∫ L(x-w) dA = 0.112600 (should ≈ 1)\n", + " p(x|O_i) = 0.026795\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2713513513513514 (step_size_phi = 0.271\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.943717 (should = 1)\n", + " ∫ L(x-w) dA = 0.112899 (should ≈ 1)\n", + " p(x|O_i) = 0.026866\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27171171171171177 (step_size_phi = 0.272\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946225 (should = 1)\n", + " ∫ L(x-w) dA = 0.113200 (should ≈ 1)\n", + " p(x|O_i) = 0.026938\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2720720720720721 (step_size_phi = 0.272\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948737 (should = 1)\n", + " ∫ L(x-w) dA = 0.113500 (should ≈ 1)\n", + " p(x|O_i) = 0.027009\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2724324324324325 (step_size_phi = 0.272\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951251 (should = 1)\n", + " ∫ L(x-w) dA = 0.113801 (should ≈ 1)\n", + " p(x|O_i) = 0.027081\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27279279279279284 (step_size_phi = 0.273\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953770 (should = 1)\n", + " ∫ L(x-w) dA = 0.114102 (should ≈ 1)\n", + " p(x|O_i) = 0.027153\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2731531531531532 (step_size_phi = 0.273\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956291 (should = 1)\n", + " ∫ L(x-w) dA = 0.114404 (should ≈ 1)\n", + " p(x|O_i) = 0.027224\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27351351351351355 (step_size_phi = 0.274\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958816 (should = 1)\n", + " ∫ L(x-w) dA = 0.114706 (should ≈ 1)\n", + " p(x|O_i) = 0.027296\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2738738738738739 (step_size_phi = 0.274\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961344 (should = 1)\n", + " ∫ L(x-w) dA = 0.115008 (should ≈ 1)\n", + " p(x|O_i) = 0.027368\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27423423423423426 (step_size_phi = 0.274\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963876 (should = 1)\n", + " ∫ L(x-w) dA = 0.115311 (should ≈ 1)\n", + " p(x|O_i) = 0.027440\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2745945945945946 (step_size_phi = 0.275\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966411 (should = 1)\n", + " ∫ L(x-w) dA = 0.115614 (should ≈ 1)\n", + " p(x|O_i) = 0.027513\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.274954954954955 (step_size_phi = 0.275\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968949 (should = 1)\n", + " ∫ L(x-w) dA = 0.115918 (should ≈ 1)\n", + " p(x|O_i) = 0.027585\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27531531531531533 (step_size_phi = 0.275\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971490 (should = 1)\n", + " ∫ L(x-w) dA = 0.116222 (should ≈ 1)\n", + " p(x|O_i) = 0.027657\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2756756756756757 (step_size_phi = 0.276\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974035 (should = 1)\n", + " ∫ L(x-w) dA = 0.116527 (should ≈ 1)\n", + " p(x|O_i) = 0.027730\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27603603603603605 (step_size_phi = 0.276\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939694 (should = 1)\n", + " ∫ L(x-w) dA = 2.037102 (should ≈ 1)\n", + " p(x|O_i) = 0.444452\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2763963963963964 (step_size_phi = 0.276\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942149 (should = 1)\n", + " ∫ L(x-w) dA = 2.042424 (should ≈ 1)\n", + " p(x|O_i) = 0.445613\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2767567567567568 (step_size_phi = 0.277\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944607 (should = 1)\n", + " ∫ L(x-w) dA = 2.047753 (should ≈ 1)\n", + " p(x|O_i) = 0.446776\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2771171171171172 (step_size_phi = 0.277\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947069 (should = 1)\n", + " ∫ L(x-w) dA = 2.053090 (should ≈ 1)\n", + " p(x|O_i) = 0.447940\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27747747747747753 (step_size_phi = 0.277\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949534 (should = 1)\n", + " ∫ L(x-w) dA = 2.058433 (should ≈ 1)\n", + " p(x|O_i) = 0.449106\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2778378378378379 (step_size_phi = 0.278\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952002 (should = 1)\n", + " ∫ L(x-w) dA = 2.063783 (should ≈ 1)\n", + " p(x|O_i) = 0.450273\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27819819819819824 (step_size_phi = 0.278\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954473 (should = 1)\n", + " ∫ L(x-w) dA = 2.069140 (should ≈ 1)\n", + " p(x|O_i) = 0.451442\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2785585585585586 (step_size_phi = 0.279\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956947 (should = 1)\n", + " ∫ L(x-w) dA = 2.074504 (should ≈ 1)\n", + " p(x|O_i) = 0.452612\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27891891891891896 (step_size_phi = 0.279\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959425 (should = 1)\n", + " ∫ L(x-w) dA = 2.079875 (should ≈ 1)\n", + " p(x|O_i) = 0.453784\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2792792792792793 (step_size_phi = 0.279\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961905 (should = 1)\n", + " ∫ L(x-w) dA = 2.085252 (should ≈ 1)\n", + " p(x|O_i) = 0.454957\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.27963963963963967 (step_size_phi = 0.280\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964389 (should = 1)\n", + " ∫ L(x-w) dA = 2.090637 (should ≈ 1)\n", + " p(x|O_i) = 0.456132\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28 (step_size_phi = 0.280\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966876 (should = 1)\n", + " ∫ L(x-w) dA = 2.096029 (should ≈ 1)\n", + " p(x|O_i) = 0.457309\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2803603603603604 (step_size_phi = 0.280\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969367 (should = 1)\n", + " ∫ L(x-w) dA = 2.101427 (should ≈ 1)\n", + " p(x|O_i) = 0.458486\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28072072072072074 (step_size_phi = 0.281\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971860 (should = 1)\n", + " ∫ L(x-w) dA = 2.106833 (should ≈ 1)\n", + " p(x|O_i) = 0.459666\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2810810810810811 (step_size_phi = 0.281\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974357 (should = 1)\n", + " ∫ L(x-w) dA = 2.112246 (should ≈ 1)\n", + " p(x|O_i) = 0.460847\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28144144144144145 (step_size_phi = 0.281\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976857 (should = 1)\n", + " ∫ L(x-w) dA = 2.117665 (should ≈ 1)\n", + " p(x|O_i) = 0.462029\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2818018018018018 (step_size_phi = 0.282\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979360 (should = 1)\n", + " ∫ L(x-w) dA = 2.123092 (should ≈ 1)\n", + " p(x|O_i) = 0.463213\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2821621621621622 (step_size_phi = 0.282\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981866 (should = 1)\n", + " ∫ L(x-w) dA = 2.128525 (should ≈ 1)\n", + " p(x|O_i) = 0.464398\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2825225225225226 (step_size_phi = 0.283\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.929809 (should = 1)\n", + " ∫ L(x-w) dA = 0.082546 (should ≈ 1)\n", + " p(x|O_i) = 0.019604\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28288288288288294 (step_size_phi = 0.283\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.932182 (should = 1)\n", + " ∫ L(x-w) dA = 0.082757 (should ≈ 1)\n", + " p(x|O_i) = 0.019654\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2832432432432433 (step_size_phi = 0.283\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.934559 (should = 1)\n", + " ∫ L(x-w) dA = 0.082968 (should ≈ 1)\n", + " p(x|O_i) = 0.019704\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28360360360360365 (step_size_phi = 0.284\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.936938 (should = 1)\n", + " ∫ L(x-w) dA = 0.083179 (should ≈ 1)\n", + " p(x|O_i) = 0.019755\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.283963963963964 (step_size_phi = 0.284\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939321 (should = 1)\n", + " ∫ L(x-w) dA = 0.083391 (should ≈ 1)\n", + " p(x|O_i) = 0.019805\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28432432432432436 (step_size_phi = 0.284\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.941706 (should = 1)\n", + " ∫ L(x-w) dA = 0.083603 (should ≈ 1)\n", + " p(x|O_i) = 0.019855\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2846846846846847 (step_size_phi = 0.285\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944095 (should = 1)\n", + " ∫ L(x-w) dA = 0.083815 (should ≈ 1)\n", + " p(x|O_i) = 0.019906\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2850450450450451 (step_size_phi = 0.285\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946486 (should = 1)\n", + " ∫ L(x-w) dA = 0.084027 (should ≈ 1)\n", + " p(x|O_i) = 0.019956\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28540540540540543 (step_size_phi = 0.285\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948881 (should = 1)\n", + " ∫ L(x-w) dA = 0.084240 (should ≈ 1)\n", + " p(x|O_i) = 0.020006\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2857657657657658 (step_size_phi = 0.286\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951279 (should = 1)\n", + " ∫ L(x-w) dA = 0.084452 (should ≈ 1)\n", + " p(x|O_i) = 0.020057\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28612612612612615 (step_size_phi = 0.286\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953679 (should = 1)\n", + " ∫ L(x-w) dA = 0.084666 (should ≈ 1)\n", + " p(x|O_i) = 0.020108\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2864864864864865 (step_size_phi = 0.286\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956083 (should = 1)\n", + " ∫ L(x-w) dA = 0.084879 (should ≈ 1)\n", + " p(x|O_i) = 0.020158\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28684684684684686 (step_size_phi = 0.287\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958490 (should = 1)\n", + " ∫ L(x-w) dA = 0.085093 (should ≈ 1)\n", + " p(x|O_i) = 0.020209\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2872072072072072 (step_size_phi = 0.287\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960900 (should = 1)\n", + " ∫ L(x-w) dA = 0.085307 (should ≈ 1)\n", + " p(x|O_i) = 0.020260\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28756756756756763 (step_size_phi = 0.288\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963313 (should = 1)\n", + " ∫ L(x-w) dA = 0.085521 (should ≈ 1)\n", + " p(x|O_i) = 0.020311\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.287927927927928 (step_size_phi = 0.288\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965728 (should = 1)\n", + " ∫ L(x-w) dA = 0.085735 (should ≈ 1)\n", + " p(x|O_i) = 0.020362\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28828828828828834 (step_size_phi = 0.288\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968147 (should = 1)\n", + " ∫ L(x-w) dA = 0.085950 (should ≈ 1)\n", + " p(x|O_i) = 0.020413\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2886486486486487 (step_size_phi = 0.289\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970569 (should = 1)\n", + " ∫ L(x-w) dA = 0.086165 (should ≈ 1)\n", + " p(x|O_i) = 0.020464\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28900900900900905 (step_size_phi = 0.289\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972994 (should = 1)\n", + " ∫ L(x-w) dA = 0.086380 (should ≈ 1)\n", + " p(x|O_i) = 0.020515\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2893693693693694 (step_size_phi = 0.289\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.937646 (should = 1)\n", + " ∫ L(x-w) dA = 1.846584 (should ≈ 1)\n", + " p(x|O_i) = 0.401523\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.28972972972972977 (step_size_phi = 0.290\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939982 (should = 1)\n", + " ∫ L(x-w) dA = 1.851186 (should ≈ 1)\n", + " p(x|O_i) = 0.402524\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2900900900900901 (step_size_phi = 0.290\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942322 (should = 1)\n", + " ∫ L(x-w) dA = 1.855794 (should ≈ 1)\n", + " p(x|O_i) = 0.403526\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2904504504504505 (step_size_phi = 0.290\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944665 (should = 1)\n", + " ∫ L(x-w) dA = 1.860407 (should ≈ 1)\n", + " p(x|O_i) = 0.404529\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29081081081081084 (step_size_phi = 0.291\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947010 (should = 1)\n", + " ∫ L(x-w) dA = 1.865027 (should ≈ 1)\n", + " p(x|O_i) = 0.405534\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2911711711711712 (step_size_phi = 0.291\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949359 (should = 1)\n", + " ∫ L(x-w) dA = 1.869652 (should ≈ 1)\n", + " p(x|O_i) = 0.406539\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29153153153153155 (step_size_phi = 0.292\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951710 (should = 1)\n", + " ∫ L(x-w) dA = 1.874282 (should ≈ 1)\n", + " p(x|O_i) = 0.407546\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2918918918918919 (step_size_phi = 0.292\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954064 (should = 1)\n", + " ∫ L(x-w) dA = 1.878919 (should ≈ 1)\n", + " p(x|O_i) = 0.408554\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29225225225225226 (step_size_phi = 0.292\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956422 (should = 1)\n", + " ∫ L(x-w) dA = 1.883561 (should ≈ 1)\n", + " p(x|O_i) = 0.409564\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2926126126126126 (step_size_phi = 0.293\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958782 (should = 1)\n", + " ∫ L(x-w) dA = 1.888209 (should ≈ 1)\n", + " p(x|O_i) = 0.410574\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.292972972972973 (step_size_phi = 0.293\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961145 (should = 1)\n", + " ∫ L(x-w) dA = 1.892862 (should ≈ 1)\n", + " p(x|O_i) = 0.411586\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29333333333333333 (step_size_phi = 0.293\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963510 (should = 1)\n", + " ∫ L(x-w) dA = 1.897522 (should ≈ 1)\n", + " p(x|O_i) = 0.412599\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2936936936936937 (step_size_phi = 0.294\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965879 (should = 1)\n", + " ∫ L(x-w) dA = 1.902187 (should ≈ 1)\n", + " p(x|O_i) = 0.413614\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2940540540540541 (step_size_phi = 0.294\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968251 (should = 1)\n", + " ∫ L(x-w) dA = 1.906858 (should ≈ 1)\n", + " p(x|O_i) = 0.414629\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29441441441441446 (step_size_phi = 0.294\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970626 (should = 1)\n", + " ∫ L(x-w) dA = 1.911534 (should ≈ 1)\n", + " p(x|O_i) = 0.415646\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2947747747747748 (step_size_phi = 0.295\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973003 (should = 1)\n", + " ∫ L(x-w) dA = 1.916217 (should ≈ 1)\n", + " p(x|O_i) = 0.416664\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2951351351351352 (step_size_phi = 0.295\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975384 (should = 1)\n", + " ∫ L(x-w) dA = 1.920905 (should ≈ 1)\n", + " p(x|O_i) = 0.417684\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29549549549549553 (step_size_phi = 0.295\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977767 (should = 1)\n", + " ∫ L(x-w) dA = 1.925598 (should ≈ 1)\n", + " p(x|O_i) = 0.418704\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2958558558558559 (step_size_phi = 0.296\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980153 (should = 1)\n", + " ∫ L(x-w) dA = 1.930298 (should ≈ 1)\n", + " p(x|O_i) = 0.419726\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29621621621621624 (step_size_phi = 0.296\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982542 (should = 1)\n", + " ∫ L(x-w) dA = 1.935003 (should ≈ 1)\n", + " p(x|O_i) = 0.420749\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2965765765765766 (step_size_phi = 0.297\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.926780 (should = 1)\n", + " ∫ L(x-w) dA = 0.057991 (should ≈ 1)\n", + " p(x|O_i) = 0.013577\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29693693693693696 (step_size_phi = 0.297\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.929034 (should = 1)\n", + " ∫ L(x-w) dA = 0.058132 (should ≈ 1)\n", + " p(x|O_i) = 0.013610\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2972972972972973 (step_size_phi = 0.297\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.931290 (should = 1)\n", + " ∫ L(x-w) dA = 0.058274 (should ≈ 1)\n", + " p(x|O_i) = 0.013643\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29765765765765767 (step_size_phi = 0.298\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.933549 (should = 1)\n", + " ∫ L(x-w) dA = 0.058415 (should ≈ 1)\n", + " p(x|O_i) = 0.013676\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.298018018018018 (step_size_phi = 0.298\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.935811 (should = 1)\n", + " ∫ L(x-w) dA = 0.058556 (should ≈ 1)\n", + " p(x|O_i) = 0.013709\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2983783783783784 (step_size_phi = 0.298\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.938075 (should = 1)\n", + " ∫ L(x-w) dA = 0.058698 (should ≈ 1)\n", + " p(x|O_i) = 0.013742\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29873873873873874 (step_size_phi = 0.299\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.940343 (should = 1)\n", + " ∫ L(x-w) dA = 0.058840 (should ≈ 1)\n", + " p(x|O_i) = 0.013775\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2990990990990991 (step_size_phi = 0.299\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942613 (should = 1)\n", + " ∫ L(x-w) dA = 0.058982 (should ≈ 1)\n", + " p(x|O_i) = 0.013809\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.2994594594594595 (step_size_phi = 0.299\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944885 (should = 1)\n", + " ∫ L(x-w) dA = 0.059124 (should ≈ 1)\n", + " p(x|O_i) = 0.013842\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.29981981981981987 (step_size_phi = 0.300\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947161 (should = 1)\n", + " ∫ L(x-w) dA = 0.059267 (should ≈ 1)\n", + " p(x|O_i) = 0.013875\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3001801801801802 (step_size_phi = 0.300\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949439 (should = 1)\n", + " ∫ L(x-w) dA = 0.059409 (should ≈ 1)\n", + " p(x|O_i) = 0.013909\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3005405405405406 (step_size_phi = 0.301\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951720 (should = 1)\n", + " ∫ L(x-w) dA = 0.059552 (should ≈ 1)\n", + " p(x|O_i) = 0.013942\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30090090090090094 (step_size_phi = 0.301\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954004 (should = 1)\n", + " ∫ L(x-w) dA = 0.059695 (should ≈ 1)\n", + " p(x|O_i) = 0.013975\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3012612612612613 (step_size_phi = 0.301\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956290 (should = 1)\n", + " ∫ L(x-w) dA = 0.059838 (should ≈ 1)\n", + " p(x|O_i) = 0.014009\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30162162162162165 (step_size_phi = 0.302\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958579 (should = 1)\n", + " ∫ L(x-w) dA = 0.059981 (should ≈ 1)\n", + " p(x|O_i) = 0.014042\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.301981981981982 (step_size_phi = 0.302\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960871 (should = 1)\n", + " ∫ L(x-w) dA = 0.060125 (should ≈ 1)\n", + " p(x|O_i) = 0.014076\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30234234234234236 (step_size_phi = 0.302\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963166 (should = 1)\n", + " ∫ L(x-w) dA = 0.060268 (should ≈ 1)\n", + " p(x|O_i) = 0.014110\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3027027027027027 (step_size_phi = 0.303\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965463 (should = 1)\n", + " ∫ L(x-w) dA = 0.060412 (should ≈ 1)\n", + " p(x|O_i) = 0.014143\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3030630630630631 (step_size_phi = 0.303\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967763 (should = 1)\n", + " ∫ L(x-w) dA = 0.060556 (should ≈ 1)\n", + " p(x|O_i) = 0.014177\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30342342342342343 (step_size_phi = 0.303\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970066 (should = 1)\n", + " ∫ L(x-w) dA = 0.060700 (should ≈ 1)\n", + " p(x|O_i) = 0.014211\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3037837837837838 (step_size_phi = 0.304\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972372 (should = 1)\n", + " ∫ L(x-w) dA = 0.060844 (should ≈ 1)\n", + " p(x|O_i) = 0.014245\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30414414414414415 (step_size_phi = 0.304\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.936042 (should = 1)\n", + " ∫ L(x-w) dA = 1.608619 (should ≈ 1)\n", + " p(x|O_i) = 0.362971\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3045045045045045 (step_size_phi = 0.305\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.938262 (should = 1)\n", + " ∫ L(x-w) dA = 1.612433 (should ≈ 1)\n", + " p(x|O_i) = 0.363832\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3048648648648649 (step_size_phi = 0.305\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.940484 (should = 1)\n", + " ∫ L(x-w) dA = 1.616251 (should ≈ 1)\n", + " p(x|O_i) = 0.364694\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30522522522522527 (step_size_phi = 0.305\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942708 (should = 1)\n", + " ∫ L(x-w) dA = 1.620075 (should ≈ 1)\n", + " p(x|O_i) = 0.365556\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30558558558558563 (step_size_phi = 0.306\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944936 (should = 1)\n", + " ∫ L(x-w) dA = 1.623902 (should ≈ 1)\n", + " p(x|O_i) = 0.366420\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.305945945945946 (step_size_phi = 0.306\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947166 (should = 1)\n", + " ∫ L(x-w) dA = 1.627735 (should ≈ 1)\n", + " p(x|O_i) = 0.367285\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30630630630630634 (step_size_phi = 0.306\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949398 (should = 1)\n", + " ∫ L(x-w) dA = 1.631571 (should ≈ 1)\n", + " p(x|O_i) = 0.368150\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3066666666666667 (step_size_phi = 0.307\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951633 (should = 1)\n", + " ∫ L(x-w) dA = 1.635412 (should ≈ 1)\n", + " p(x|O_i) = 0.369017\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30702702702702706 (step_size_phi = 0.307\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953871 (should = 1)\n", + " ∫ L(x-w) dA = 1.639258 (should ≈ 1)\n", + " p(x|O_i) = 0.369885\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3073873873873874 (step_size_phi = 0.307\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956112 (should = 1)\n", + " ∫ L(x-w) dA = 1.643109 (should ≈ 1)\n", + " p(x|O_i) = 0.370754\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30774774774774777 (step_size_phi = 0.308\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958355 (should = 1)\n", + " ∫ L(x-w) dA = 1.646963 (should ≈ 1)\n", + " p(x|O_i) = 0.371623\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3081081081081081 (step_size_phi = 0.308\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960600 (should = 1)\n", + " ∫ L(x-w) dA = 1.650823 (should ≈ 1)\n", + " p(x|O_i) = 0.372494\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3084684684684685 (step_size_phi = 0.308\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962849 (should = 1)\n", + " ∫ L(x-w) dA = 1.654686 (should ≈ 1)\n", + " p(x|O_i) = 0.373366\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30882882882882884 (step_size_phi = 0.309\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965100 (should = 1)\n", + " ∫ L(x-w) dA = 1.658555 (should ≈ 1)\n", + " p(x|O_i) = 0.374239\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3091891891891892 (step_size_phi = 0.309\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967353 (should = 1)\n", + " ∫ L(x-w) dA = 1.662428 (should ≈ 1)\n", + " p(x|O_i) = 0.375113\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.30954954954954955 (step_size_phi = 0.310\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969610 (should = 1)\n", + " ∫ L(x-w) dA = 1.666305 (should ≈ 1)\n", + " p(x|O_i) = 0.375988\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3099099099099099 (step_size_phi = 0.310\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971868 (should = 1)\n", + " ∫ L(x-w) dA = 1.670187 (should ≈ 1)\n", + " p(x|O_i) = 0.376864\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3102702702702703 (step_size_phi = 0.310\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974130 (should = 1)\n", + " ∫ L(x-w) dA = 1.674073 (should ≈ 1)\n", + " p(x|O_i) = 0.377741\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3106306306306307 (step_size_phi = 0.311\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976394 (should = 1)\n", + " ∫ L(x-w) dA = 1.677964 (should ≈ 1)\n", + " p(x|O_i) = 0.378619\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31099099099099103 (step_size_phi = 0.311\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978661 (should = 1)\n", + " ∫ L(x-w) dA = 1.681860 (should ≈ 1)\n", + " p(x|O_i) = 0.379498\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3113513513513514 (step_size_phi = 0.311\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980930 (should = 1)\n", + " ∫ L(x-w) dA = 1.685760 (should ≈ 1)\n", + " p(x|O_i) = 0.380378\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31171171171171175 (step_size_phi = 0.312\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.921092 (should = 1)\n", + " ∫ L(x-w) dA = 0.037934 (should ≈ 1)\n", + " p(x|O_i) = 0.008632\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3120720720720721 (step_size_phi = 0.312\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.923223 (should = 1)\n", + " ∫ L(x-w) dA = 0.038022 (should ≈ 1)\n", + " p(x|O_i) = 0.008652\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31243243243243246 (step_size_phi = 0.312\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.925356 (should = 1)\n", + " ∫ L(x-w) dA = 0.038110 (should ≈ 1)\n", + " p(x|O_i) = 0.008672\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3127927927927928 (step_size_phi = 0.313\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.927492 (should = 1)\n", + " ∫ L(x-w) dA = 0.038198 (should ≈ 1)\n", + " p(x|O_i) = 0.008692\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3131531531531532 (step_size_phi = 0.313\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.929630 (should = 1)\n", + " ∫ L(x-w) dA = 0.038286 (should ≈ 1)\n", + " p(x|O_i) = 0.008712\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31351351351351353 (step_size_phi = 0.314\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.931771 (should = 1)\n", + " ∫ L(x-w) dA = 0.038374 (should ≈ 1)\n", + " p(x|O_i) = 0.008732\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3138738738738739 (step_size_phi = 0.314\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.933914 (should = 1)\n", + " ∫ L(x-w) dA = 0.038463 (should ≈ 1)\n", + " p(x|O_i) = 0.008752\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31423423423423424 (step_size_phi = 0.314\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.936060 (should = 1)\n", + " ∫ L(x-w) dA = 0.038551 (should ≈ 1)\n", + " p(x|O_i) = 0.008772\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3145945945945946 (step_size_phi = 0.315\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.938208 (should = 1)\n", + " ∫ L(x-w) dA = 0.038639 (should ≈ 1)\n", + " p(x|O_i) = 0.008792\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31495495495495496 (step_size_phi = 0.315\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.940359 (should = 1)\n", + " ∫ L(x-w) dA = 0.038728 (should ≈ 1)\n", + " p(x|O_i) = 0.008812\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3153153153153153 (step_size_phi = 0.315\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942512 (should = 1)\n", + " ∫ L(x-w) dA = 0.038817 (should ≈ 1)\n", + " p(x|O_i) = 0.008833\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3156756756756757 (step_size_phi = 0.316\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944667 (should = 1)\n", + " ∫ L(x-w) dA = 0.038905 (should ≈ 1)\n", + " p(x|O_i) = 0.008853\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3160360360360361 (step_size_phi = 0.316\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946825 (should = 1)\n", + " ∫ L(x-w) dA = 0.038994 (should ≈ 1)\n", + " p(x|O_i) = 0.008873\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31639639639639644 (step_size_phi = 0.316\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948986 (should = 1)\n", + " ∫ L(x-w) dA = 0.039083 (should ≈ 1)\n", + " p(x|O_i) = 0.008893\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3167567567567568 (step_size_phi = 0.317\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951149 (should = 1)\n", + " ∫ L(x-w) dA = 0.039172 (should ≈ 1)\n", + " p(x|O_i) = 0.008914\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31711711711711715 (step_size_phi = 0.317\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953314 (should = 1)\n", + " ∫ L(x-w) dA = 0.039261 (should ≈ 1)\n", + " p(x|O_i) = 0.008934\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3174774774774775 (step_size_phi = 0.317\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955482 (should = 1)\n", + " ∫ L(x-w) dA = 0.039351 (should ≈ 1)\n", + " p(x|O_i) = 0.008954\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31783783783783787 (step_size_phi = 0.318\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.957652 (should = 1)\n", + " ∫ L(x-w) dA = 0.039440 (should ≈ 1)\n", + " p(x|O_i) = 0.008975\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3181981981981982 (step_size_phi = 0.318\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959825 (should = 1)\n", + " ∫ L(x-w) dA = 0.039530 (should ≈ 1)\n", + " p(x|O_i) = 0.008995\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3185585585585586 (step_size_phi = 0.319\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962000 (should = 1)\n", + " ∫ L(x-w) dA = 0.039619 (should ≈ 1)\n", + " p(x|O_i) = 0.009015\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31891891891891894 (step_size_phi = 0.319\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964178 (should = 1)\n", + " ∫ L(x-w) dA = 0.039709 (should ≈ 1)\n", + " p(x|O_i) = 0.009036\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3192792792792793 (step_size_phi = 0.319\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966358 (should = 1)\n", + " ∫ L(x-w) dA = 0.039799 (should ≈ 1)\n", + " p(x|O_i) = 0.009056\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.31963963963963965 (step_size_phi = 0.320\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968541 (should = 1)\n", + " ∫ L(x-w) dA = 0.039889 (should ≈ 1)\n", + " p(x|O_i) = 0.009077\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32 (step_size_phi = 0.320\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970726 (should = 1)\n", + " ∫ L(x-w) dA = 0.039979 (should ≈ 1)\n", + " p(x|O_i) = 0.009097\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32036036036036036 (step_size_phi = 0.320\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.933546 (should = 1)\n", + " ∫ L(x-w) dA = 1.436840 (should ≈ 1)\n", + " p(x|O_i) = 0.355405\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3207207207207207 (step_size_phi = 0.321\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.935647 (should = 1)\n", + " ∫ L(x-w) dA = 1.440074 (should ≈ 1)\n", + " p(x|O_i) = 0.356205\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32108108108108113 (step_size_phi = 0.321\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.937751 (should = 1)\n", + " ∫ L(x-w) dA = 1.443312 (should ≈ 1)\n", + " p(x|O_i) = 0.357006\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3214414414414415 (step_size_phi = 0.321\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939857 (should = 1)\n", + " ∫ L(x-w) dA = 1.446554 (should ≈ 1)\n", + " p(x|O_i) = 0.357807\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32180180180180185 (step_size_phi = 0.322\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.941965 (should = 1)\n", + " ∫ L(x-w) dA = 1.449799 (should ≈ 1)\n", + " p(x|O_i) = 0.358610\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3221621621621622 (step_size_phi = 0.322\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944076 (should = 1)\n", + " ∫ L(x-w) dA = 1.453048 (should ≈ 1)\n", + " p(x|O_i) = 0.359414\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32252252252252256 (step_size_phi = 0.323\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946189 (should = 1)\n", + " ∫ L(x-w) dA = 1.456300 (should ≈ 1)\n", + " p(x|O_i) = 0.360218\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3228828828828829 (step_size_phi = 0.323\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948305 (should = 1)\n", + " ∫ L(x-w) dA = 1.459556 (should ≈ 1)\n", + " p(x|O_i) = 0.361024\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3232432432432433 (step_size_phi = 0.323\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950423 (should = 1)\n", + " ∫ L(x-w) dA = 1.462816 (should ≈ 1)\n", + " p(x|O_i) = 0.361830\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32360360360360363 (step_size_phi = 0.324\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952543 (should = 1)\n", + " ∫ L(x-w) dA = 1.466079 (should ≈ 1)\n", + " p(x|O_i) = 0.362637\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.323963963963964 (step_size_phi = 0.324\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954666 (should = 1)\n", + " ∫ L(x-w) dA = 1.469346 (should ≈ 1)\n", + " p(x|O_i) = 0.363445\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32432432432432434 (step_size_phi = 0.324\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956791 (should = 1)\n", + " ∫ L(x-w) dA = 1.472617 (should ≈ 1)\n", + " p(x|O_i) = 0.364254\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3246846846846847 (step_size_phi = 0.325\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958918 (should = 1)\n", + " ∫ L(x-w) dA = 1.475891 (should ≈ 1)\n", + " p(x|O_i) = 0.365064\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32504504504504506 (step_size_phi = 0.325\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961048 (should = 1)\n", + " ∫ L(x-w) dA = 1.479169 (should ≈ 1)\n", + " p(x|O_i) = 0.365875\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3254054054054054 (step_size_phi = 0.325\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963180 (should = 1)\n", + " ∫ L(x-w) dA = 1.482451 (should ≈ 1)\n", + " p(x|O_i) = 0.366687\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32576576576576577 (step_size_phi = 0.326\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965315 (should = 1)\n", + " ∫ L(x-w) dA = 1.485736 (should ≈ 1)\n", + " p(x|O_i) = 0.367499\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3261261261261262 (step_size_phi = 0.326\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967451 (should = 1)\n", + " ∫ L(x-w) dA = 1.489025 (should ≈ 1)\n", + " p(x|O_i) = 0.368313\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32648648648648654 (step_size_phi = 0.326\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969591 (should = 1)\n", + " ∫ L(x-w) dA = 1.492317 (should ≈ 1)\n", + " p(x|O_i) = 0.369127\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3268468468468469 (step_size_phi = 0.327\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971732 (should = 1)\n", + " ∫ L(x-w) dA = 1.495614 (should ≈ 1)\n", + " p(x|O_i) = 0.369943\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32720720720720725 (step_size_phi = 0.327\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973876 (should = 1)\n", + " ∫ L(x-w) dA = 1.498913 (should ≈ 1)\n", + " p(x|O_i) = 0.370759\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3275675675675676 (step_size_phi = 0.328\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976022 (should = 1)\n", + " ∫ L(x-w) dA = 1.502217 (should ≈ 1)\n", + " p(x|O_i) = 0.371576\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32792792792792796 (step_size_phi = 0.328\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978171 (should = 1)\n", + " ∫ L(x-w) dA = 1.505524 (should ≈ 1)\n", + " p(x|O_i) = 0.372394\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3282882882882883 (step_size_phi = 0.328\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980322 (should = 1)\n", + " ∫ L(x-w) dA = 1.508834 (should ≈ 1)\n", + " p(x|O_i) = 0.373213\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3286486486486487 (step_size_phi = 0.329\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982475 (should = 1)\n", + " ∫ L(x-w) dA = 1.512149 (should ≈ 1)\n", + " p(x|O_i) = 0.374033\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32900900900900903 (step_size_phi = 0.329\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.917748 (should = 1)\n", + " ∫ L(x-w) dA = 0.022776 (should ≈ 1)\n", + " p(x|O_i) = 0.004976\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3293693693693694 (step_size_phi = 0.329\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.919760 (should = 1)\n", + " ∫ L(x-w) dA = 0.022826 (should ≈ 1)\n", + " p(x|O_i) = 0.004987\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.32972972972972975 (step_size_phi = 0.330\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.921773 (should = 1)\n", + " ∫ L(x-w) dA = 0.022876 (should ≈ 1)\n", + " p(x|O_i) = 0.004998\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3300900900900901 (step_size_phi = 0.330\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.923789 (should = 1)\n", + " ∫ L(x-w) dA = 0.022926 (should ≈ 1)\n", + " p(x|O_i) = 0.005009\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33045045045045046 (step_size_phi = 0.330\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.925807 (should = 1)\n", + " ∫ L(x-w) dA = 0.022976 (should ≈ 1)\n", + " p(x|O_i) = 0.005020\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3308108108108108 (step_size_phi = 0.331\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.927828 (should = 1)\n", + " ∫ L(x-w) dA = 0.023026 (should ≈ 1)\n", + " p(x|O_i) = 0.005031\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3311711711711712 (step_size_phi = 0.331\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.929850 (should = 1)\n", + " ∫ L(x-w) dA = 0.023076 (should ≈ 1)\n", + " p(x|O_i) = 0.005042\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3315315315315316 (step_size_phi = 0.332\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.931875 (should = 1)\n", + " ∫ L(x-w) dA = 0.023127 (should ≈ 1)\n", + " p(x|O_i) = 0.005053\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33189189189189194 (step_size_phi = 0.332\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.933902 (should = 1)\n", + " ∫ L(x-w) dA = 0.023177 (should ≈ 1)\n", + " p(x|O_i) = 0.005064\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3322522522522523 (step_size_phi = 0.332\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.935931 (should = 1)\n", + " ∫ L(x-w) dA = 0.023227 (should ≈ 1)\n", + " p(x|O_i) = 0.005075\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33261261261261266 (step_size_phi = 0.333\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.937962 (should = 1)\n", + " ∫ L(x-w) dA = 0.023278 (should ≈ 1)\n", + " p(x|O_i) = 0.005086\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.332972972972973 (step_size_phi = 0.333\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939996 (should = 1)\n", + " ∫ L(x-w) dA = 0.023328 (should ≈ 1)\n", + " p(x|O_i) = 0.005097\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33333333333333337 (step_size_phi = 0.333\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942032 (should = 1)\n", + " ∫ L(x-w) dA = 0.023379 (should ≈ 1)\n", + " p(x|O_i) = 0.005108\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3336936936936937 (step_size_phi = 0.334\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944070 (should = 1)\n", + " ∫ L(x-w) dA = 0.023429 (should ≈ 1)\n", + " p(x|O_i) = 0.005119\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3340540540540541 (step_size_phi = 0.334\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946110 (should = 1)\n", + " ∫ L(x-w) dA = 0.023480 (should ≈ 1)\n", + " p(x|O_i) = 0.005130\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33441441441441444 (step_size_phi = 0.334\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948152 (should = 1)\n", + " ∫ L(x-w) dA = 0.023531 (should ≈ 1)\n", + " p(x|O_i) = 0.005141\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3347747747747748 (step_size_phi = 0.335\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950197 (should = 1)\n", + " ∫ L(x-w) dA = 0.023581 (should ≈ 1)\n", + " p(x|O_i) = 0.005152\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33513513513513515 (step_size_phi = 0.335\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952243 (should = 1)\n", + " ∫ L(x-w) dA = 0.023632 (should ≈ 1)\n", + " p(x|O_i) = 0.005163\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3354954954954955 (step_size_phi = 0.335\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954292 (should = 1)\n", + " ∫ L(x-w) dA = 0.023683 (should ≈ 1)\n", + " p(x|O_i) = 0.005174\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33585585585585587 (step_size_phi = 0.336\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956343 (should = 1)\n", + " ∫ L(x-w) dA = 0.023734 (should ≈ 1)\n", + " p(x|O_i) = 0.005185\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3362162162162162 (step_size_phi = 0.336\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958397 (should = 1)\n", + " ∫ L(x-w) dA = 0.023785 (should ≈ 1)\n", + " p(x|O_i) = 0.005196\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3365765765765766 (step_size_phi = 0.337\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960452 (should = 1)\n", + " ∫ L(x-w) dA = 0.023836 (should ≈ 1)\n", + " p(x|O_i) = 0.005207\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.336936936936937 (step_size_phi = 0.337\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962510 (should = 1)\n", + " ∫ L(x-w) dA = 0.023887 (should ≈ 1)\n", + " p(x|O_i) = 0.005219\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33729729729729735 (step_size_phi = 0.337\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964570 (should = 1)\n", + " ∫ L(x-w) dA = 0.023938 (should ≈ 1)\n", + " p(x|O_i) = 0.005230\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3376576576576577 (step_size_phi = 0.338\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966632 (should = 1)\n", + " ∫ L(x-w) dA = 0.023989 (should ≈ 1)\n", + " p(x|O_i) = 0.005241\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33801801801801806 (step_size_phi = 0.338\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968696 (should = 1)\n", + " ∫ L(x-w) dA = 0.024040 (should ≈ 1)\n", + " p(x|O_i) = 0.005252\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3383783783783784 (step_size_phi = 0.338\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.930822 (should = 1)\n", + " ∫ L(x-w) dA = 1.482274 (should ≈ 1)\n", + " p(x|O_i) = 0.408381\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3387387387387388 (step_size_phi = 0.339\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.932806 (should = 1)\n", + " ∫ L(x-w) dA = 1.485433 (should ≈ 1)\n", + " p(x|O_i) = 0.409251\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33909909909909913 (step_size_phi = 0.339\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.934791 (should = 1)\n", + " ∫ L(x-w) dA = 1.488595 (should ≈ 1)\n", + " p(x|O_i) = 0.410122\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3394594594594595 (step_size_phi = 0.339\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.936779 (should = 1)\n", + " ∫ L(x-w) dA = 1.491761 (should ≈ 1)\n", + " p(x|O_i) = 0.410994\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.33981981981981985 (step_size_phi = 0.340\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.938769 (should = 1)\n", + " ∫ L(x-w) dA = 1.494930 (should ≈ 1)\n", + " p(x|O_i) = 0.411867\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3401801801801802 (step_size_phi = 0.340\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.940761 (should = 1)\n", + " ∫ L(x-w) dA = 1.498102 (should ≈ 1)\n", + " p(x|O_i) = 0.412741\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34054054054054056 (step_size_phi = 0.341\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942755 (should = 1)\n", + " ∫ L(x-w) dA = 1.501278 (should ≈ 1)\n", + " p(x|O_i) = 0.413616\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3409009009009009 (step_size_phi = 0.341\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944752 (should = 1)\n", + " ∫ L(x-w) dA = 1.504457 (should ≈ 1)\n", + " p(x|O_i) = 0.414492\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3412612612612613 (step_size_phi = 0.341\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946750 (should = 1)\n", + " ∫ L(x-w) dA = 1.507639 (should ≈ 1)\n", + " p(x|O_i) = 0.415369\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34162162162162163 (step_size_phi = 0.342\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948751 (should = 1)\n", + " ∫ L(x-w) dA = 1.510825 (should ≈ 1)\n", + " p(x|O_i) = 0.416246\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.341981981981982 (step_size_phi = 0.342\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950753 (should = 1)\n", + " ∫ L(x-w) dA = 1.514014 (should ≈ 1)\n", + " p(x|O_i) = 0.417125\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3423423423423424 (step_size_phi = 0.342\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952758 (should = 1)\n", + " ∫ L(x-w) dA = 1.517206 (should ≈ 1)\n", + " p(x|O_i) = 0.418005\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34270270270270276 (step_size_phi = 0.343\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954765 (should = 1)\n", + " ∫ L(x-w) dA = 1.520402 (should ≈ 1)\n", + " p(x|O_i) = 0.418885\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3430630630630631 (step_size_phi = 0.343\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956774 (should = 1)\n", + " ∫ L(x-w) dA = 1.523601 (should ≈ 1)\n", + " p(x|O_i) = 0.419767\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34342342342342347 (step_size_phi = 0.343\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958785 (should = 1)\n", + " ∫ L(x-w) dA = 1.526804 (should ≈ 1)\n", + " p(x|O_i) = 0.420649\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3437837837837838 (step_size_phi = 0.344\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960798 (should = 1)\n", + " ∫ L(x-w) dA = 1.530010 (should ≈ 1)\n", + " p(x|O_i) = 0.421532\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3441441441441442 (step_size_phi = 0.344\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962814 (should = 1)\n", + " ∫ L(x-w) dA = 1.533219 (should ≈ 1)\n", + " p(x|O_i) = 0.422416\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34450450450450454 (step_size_phi = 0.345\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964831 (should = 1)\n", + " ∫ L(x-w) dA = 1.536432 (should ≈ 1)\n", + " p(x|O_i) = 0.423301\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3448648648648649 (step_size_phi = 0.345\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966850 (should = 1)\n", + " ∫ L(x-w) dA = 1.539648 (should ≈ 1)\n", + " p(x|O_i) = 0.424187\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34522522522522525 (step_size_phi = 0.345\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.968872 (should = 1)\n", + " ∫ L(x-w) dA = 1.542867 (should ≈ 1)\n", + " p(x|O_i) = 0.425074\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3455855855855856 (step_size_phi = 0.346\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.970896 (should = 1)\n", + " ∫ L(x-w) dA = 1.546090 (should ≈ 1)\n", + " p(x|O_i) = 0.425962\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34594594594594597 (step_size_phi = 0.346\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.972922 (should = 1)\n", + " ∫ L(x-w) dA = 1.549316 (should ≈ 1)\n", + " p(x|O_i) = 0.426851\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3463063063063063 (step_size_phi = 0.346\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974950 (should = 1)\n", + " ∫ L(x-w) dA = 1.552545 (should ≈ 1)\n", + " p(x|O_i) = 0.427741\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3466666666666667 (step_size_phi = 0.347\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976980 (should = 1)\n", + " ∫ L(x-w) dA = 1.555778 (should ≈ 1)\n", + " p(x|O_i) = 0.428631\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34702702702702704 (step_size_phi = 0.347\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979012 (should = 1)\n", + " ∫ L(x-w) dA = 1.559014 (should ≈ 1)\n", + " p(x|O_i) = 0.429523\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3473873873873874 (step_size_phi = 0.347\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981046 (should = 1)\n", + " ∫ L(x-w) dA = 1.562254 (should ≈ 1)\n", + " p(x|O_i) = 0.430416\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3477477477477478 (step_size_phi = 0.348\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983083 (should = 1)\n", + " ∫ L(x-w) dA = 1.565496 (should ≈ 1)\n", + " p(x|O_i) = 0.431309\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34810810810810816 (step_size_phi = 0.348\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.912746 (should = 1)\n", + " ∫ L(x-w) dA = 0.012246 (should ≈ 1)\n", + " p(x|O_i) = 0.002550\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3484684684684685 (step_size_phi = 0.348\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.914637 (should = 1)\n", + " ∫ L(x-w) dA = 0.012271 (should ≈ 1)\n", + " p(x|O_i) = 0.002555\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3488288288288289 (step_size_phi = 0.349\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.916529 (should = 1)\n", + " ∫ L(x-w) dA = 0.012297 (should ≈ 1)\n", + " p(x|O_i) = 0.002561\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34918918918918923 (step_size_phi = 0.349\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.918424 (should = 1)\n", + " ∫ L(x-w) dA = 0.012322 (should ≈ 1)\n", + " p(x|O_i) = 0.002566\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3495495495495496 (step_size_phi = 0.350\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.920321 (should = 1)\n", + " ∫ L(x-w) dA = 0.012348 (should ≈ 1)\n", + " p(x|O_i) = 0.002571\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.34990990990990994 (step_size_phi = 0.350\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.922219 (should = 1)\n", + " ∫ L(x-w) dA = 0.012373 (should ≈ 1)\n", + " p(x|O_i) = 0.002577\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3502702702702703 (step_size_phi = 0.350\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.924120 (should = 1)\n", + " ∫ L(x-w) dA = 0.012399 (should ≈ 1)\n", + " p(x|O_i) = 0.002582\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35063063063063066 (step_size_phi = 0.351\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.926022 (should = 1)\n", + " ∫ L(x-w) dA = 0.012424 (should ≈ 1)\n", + " p(x|O_i) = 0.002587\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.350990990990991 (step_size_phi = 0.351\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.927927 (should = 1)\n", + " ∫ L(x-w) dA = 0.012450 (should ≈ 1)\n", + " p(x|O_i) = 0.002593\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35135135135135137 (step_size_phi = 0.351\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.929833 (should = 1)\n", + " ∫ L(x-w) dA = 0.012475 (should ≈ 1)\n", + " p(x|O_i) = 0.002598\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3517117117117117 (step_size_phi = 0.352\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.931741 (should = 1)\n", + " ∫ L(x-w) dA = 0.012501 (should ≈ 1)\n", + " p(x|O_i) = 0.002603\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3520720720720721 (step_size_phi = 0.352\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.933652 (should = 1)\n", + " ∫ L(x-w) dA = 0.012526 (should ≈ 1)\n", + " p(x|O_i) = 0.002609\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35243243243243244 (step_size_phi = 0.352\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.935564 (should = 1)\n", + " ∫ L(x-w) dA = 0.012552 (should ≈ 1)\n", + " p(x|O_i) = 0.002614\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3527927927927928 (step_size_phi = 0.353\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.937478 (should = 1)\n", + " ∫ L(x-w) dA = 0.012578 (should ≈ 1)\n", + " p(x|O_i) = 0.002619\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3531531531531532 (step_size_phi = 0.353\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939394 (should = 1)\n", + " ∫ L(x-w) dA = 0.012604 (should ≈ 1)\n", + " p(x|O_i) = 0.002625\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35351351351351357 (step_size_phi = 0.354\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.941312 (should = 1)\n", + " ∫ L(x-w) dA = 0.012629 (should ≈ 1)\n", + " p(x|O_i) = 0.002630\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3538738738738739 (step_size_phi = 0.354\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.943232 (should = 1)\n", + " ∫ L(x-w) dA = 0.012655 (should ≈ 1)\n", + " p(x|O_i) = 0.002635\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3542342342342343 (step_size_phi = 0.354\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.945154 (should = 1)\n", + " ∫ L(x-w) dA = 0.012681 (should ≈ 1)\n", + " p(x|O_i) = 0.002641\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35459459459459464 (step_size_phi = 0.355\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947078 (should = 1)\n", + " ∫ L(x-w) dA = 0.012707 (should ≈ 1)\n", + " p(x|O_i) = 0.002646\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.354954954954955 (step_size_phi = 0.355\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949004 (should = 1)\n", + " ∫ L(x-w) dA = 0.012732 (should ≈ 1)\n", + " p(x|O_i) = 0.002651\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35531531531531535 (step_size_phi = 0.355\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950932 (should = 1)\n", + " ∫ L(x-w) dA = 0.012758 (should ≈ 1)\n", + " p(x|O_i) = 0.002657\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3556756756756757 (step_size_phi = 0.356\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952862 (should = 1)\n", + " ∫ L(x-w) dA = 0.012784 (should ≈ 1)\n", + " p(x|O_i) = 0.002662\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35603603603603606 (step_size_phi = 0.356\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954794 (should = 1)\n", + " ∫ L(x-w) dA = 0.012810 (should ≈ 1)\n", + " p(x|O_i) = 0.002668\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3563963963963964 (step_size_phi = 0.356\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956728 (should = 1)\n", + " ∫ L(x-w) dA = 0.012836 (should ≈ 1)\n", + " p(x|O_i) = 0.002673\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3567567567567568 (step_size_phi = 0.357\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958663 (should = 1)\n", + " ∫ L(x-w) dA = 0.012862 (should ≈ 1)\n", + " p(x|O_i) = 0.002678\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35711711711711713 (step_size_phi = 0.357\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960601 (should = 1)\n", + " ∫ L(x-w) dA = 0.012888 (should ≈ 1)\n", + " p(x|O_i) = 0.002684\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3574774774774775 (step_size_phi = 0.357\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962541 (should = 1)\n", + " ∫ L(x-w) dA = 0.012914 (should ≈ 1)\n", + " p(x|O_i) = 0.002689\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35783783783783785 (step_size_phi = 0.358\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964482 (should = 1)\n", + " ∫ L(x-w) dA = 0.012940 (should ≈ 1)\n", + " p(x|O_i) = 0.002695\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3581981981981982 (step_size_phi = 0.358\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.966426 (should = 1)\n", + " ∫ L(x-w) dA = 0.012966 (should ≈ 1)\n", + " p(x|O_i) = 0.002700\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3585585585585586 (step_size_phi = 0.359\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.928110 (should = 1)\n", + " ∫ L(x-w) dA = 1.881295 (should ≈ 1)\n", + " p(x|O_i) = 0.544280\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35891891891891897 (step_size_phi = 0.359\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.929976 (should = 1)\n", + " ∫ L(x-w) dA = 1.885078 (should ≈ 1)\n", + " p(x|O_i) = 0.545375\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.35927927927927933 (step_size_phi = 0.359\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.931845 (should = 1)\n", + " ∫ L(x-w) dA = 1.888865 (should ≈ 1)\n", + " p(x|O_i) = 0.546470\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3596396396396397 (step_size_phi = 0.360\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.933715 (should = 1)\n", + " ∫ L(x-w) dA = 1.892656 (should ≈ 1)\n", + " p(x|O_i) = 0.547567\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36000000000000004 (step_size_phi = 0.360\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.935587 (should = 1)\n", + " ∫ L(x-w) dA = 1.896451 (should ≈ 1)\n", + " p(x|O_i) = 0.548665\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3603603603603604 (step_size_phi = 0.360\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.937461 (should = 1)\n", + " ∫ L(x-w) dA = 1.900250 (should ≈ 1)\n", + " p(x|O_i) = 0.549764\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36072072072072076 (step_size_phi = 0.361\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939337 (should = 1)\n", + " ∫ L(x-w) dA = 1.904052 (should ≈ 1)\n", + " p(x|O_i) = 0.550864\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3610810810810811 (step_size_phi = 0.361\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.941215 (should = 1)\n", + " ∫ L(x-w) dA = 1.907858 (should ≈ 1)\n", + " p(x|O_i) = 0.551965\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36144144144144147 (step_size_phi = 0.361\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.943094 (should = 1)\n", + " ∫ L(x-w) dA = 1.911668 (should ≈ 1)\n", + " p(x|O_i) = 0.553067\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3618018018018018 (step_size_phi = 0.362\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944976 (should = 1)\n", + " ∫ L(x-w) dA = 1.915482 (should ≈ 1)\n", + " p(x|O_i) = 0.554171\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3621621621621622 (step_size_phi = 0.362\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946859 (should = 1)\n", + " ∫ L(x-w) dA = 1.919300 (should ≈ 1)\n", + " p(x|O_i) = 0.555275\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36252252252252254 (step_size_phi = 0.363\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948744 (should = 1)\n", + " ∫ L(x-w) dA = 1.923121 (should ≈ 1)\n", + " p(x|O_i) = 0.556381\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3628828828828829 (step_size_phi = 0.363\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950631 (should = 1)\n", + " ∫ L(x-w) dA = 1.926946 (should ≈ 1)\n", + " p(x|O_i) = 0.557488\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36324324324324325 (step_size_phi = 0.363\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952520 (should = 1)\n", + " ∫ L(x-w) dA = 1.930775 (should ≈ 1)\n", + " p(x|O_i) = 0.558595\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36360360360360366 (step_size_phi = 0.364\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954411 (should = 1)\n", + " ∫ L(x-w) dA = 1.934608 (should ≈ 1)\n", + " p(x|O_i) = 0.559704\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.363963963963964 (step_size_phi = 0.364\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956304 (should = 1)\n", + " ∫ L(x-w) dA = 1.938445 (should ≈ 1)\n", + " p(x|O_i) = 0.560814\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3643243243243244 (step_size_phi = 0.364\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958199 (should = 1)\n", + " ∫ L(x-w) dA = 1.942285 (should ≈ 1)\n", + " p(x|O_i) = 0.561925\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36468468468468473 (step_size_phi = 0.365\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960095 (should = 1)\n", + " ∫ L(x-w) dA = 1.946129 (should ≈ 1)\n", + " p(x|O_i) = 0.563037\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3650450450450451 (step_size_phi = 0.365\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961993 (should = 1)\n", + " ∫ L(x-w) dA = 1.949977 (should ≈ 1)\n", + " p(x|O_i) = 0.564151\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36540540540540545 (step_size_phi = 0.365\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963894 (should = 1)\n", + " ∫ L(x-w) dA = 1.953829 (should ≈ 1)\n", + " p(x|O_i) = 0.565265\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3657657657657658 (step_size_phi = 0.366\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965796 (should = 1)\n", + " ∫ L(x-w) dA = 1.957685 (should ≈ 1)\n", + " p(x|O_i) = 0.566381\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36612612612612616 (step_size_phi = 0.366\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967700 (should = 1)\n", + " ∫ L(x-w) dA = 1.961544 (should ≈ 1)\n", + " p(x|O_i) = 0.567497\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3664864864864865 (step_size_phi = 0.366\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969606 (should = 1)\n", + " ∫ L(x-w) dA = 1.965407 (should ≈ 1)\n", + " p(x|O_i) = 0.568615\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3668468468468469 (step_size_phi = 0.367\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971513 (should = 1)\n", + " ∫ L(x-w) dA = 1.969274 (should ≈ 1)\n", + " p(x|O_i) = 0.569734\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36720720720720723 (step_size_phi = 0.367\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973423 (should = 1)\n", + " ∫ L(x-w) dA = 1.973145 (should ≈ 1)\n", + " p(x|O_i) = 0.570853\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3675675675675676 (step_size_phi = 0.368\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.975334 (should = 1)\n", + " ∫ L(x-w) dA = 1.977020 (should ≈ 1)\n", + " p(x|O_i) = 0.571974\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36792792792792794 (step_size_phi = 0.368\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.977248 (should = 1)\n", + " ∫ L(x-w) dA = 1.980898 (should ≈ 1)\n", + " p(x|O_i) = 0.573096\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3682882882882883 (step_size_phi = 0.368\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.979163 (should = 1)\n", + " ∫ L(x-w) dA = 1.984780 (should ≈ 1)\n", + " p(x|O_i) = 0.574220\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36864864864864866 (step_size_phi = 0.369\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.981080 (should = 1)\n", + " ∫ L(x-w) dA = 1.988666 (should ≈ 1)\n", + " p(x|O_i) = 0.575344\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.36900900900900907 (step_size_phi = 0.369\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982999 (should = 1)\n", + " ∫ L(x-w) dA = 1.992556 (should ≈ 1)\n", + " p(x|O_i) = 0.576469\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3693693693693694 (step_size_phi = 0.369\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.906115 (should = 1)\n", + " ∫ L(x-w) dA = 0.005745 (should ≈ 1)\n", + " p(x|O_i) = 0.001141\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3697297297297298 (step_size_phi = 0.370\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.907884 (should = 1)\n", + " ∫ L(x-w) dA = 0.005757 (should ≈ 1)\n", + " p(x|O_i) = 0.001143\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37009009009009014 (step_size_phi = 0.370\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.909655 (should = 1)\n", + " ∫ L(x-w) dA = 0.005768 (should ≈ 1)\n", + " p(x|O_i) = 0.001145\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3704504504504505 (step_size_phi = 0.370\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.911427 (should = 1)\n", + " ∫ L(x-w) dA = 0.005779 (should ≈ 1)\n", + " p(x|O_i) = 0.001147\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37081081081081085 (step_size_phi = 0.371\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.913201 (should = 1)\n", + " ∫ L(x-w) dA = 0.005790 (should ≈ 1)\n", + " p(x|O_i) = 0.001149\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3711711711711712 (step_size_phi = 0.371\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.914977 (should = 1)\n", + " ∫ L(x-w) dA = 0.005802 (should ≈ 1)\n", + " p(x|O_i) = 0.001152\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37153153153153157 (step_size_phi = 0.372\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.916755 (should = 1)\n", + " ∫ L(x-w) dA = 0.005813 (should ≈ 1)\n", + " p(x|O_i) = 0.001154\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3718918918918919 (step_size_phi = 0.372\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.918534 (should = 1)\n", + " ∫ L(x-w) dA = 0.005824 (should ≈ 1)\n", + " p(x|O_i) = 0.001156\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3722522522522523 (step_size_phi = 0.372\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.920315 (should = 1)\n", + " ∫ L(x-w) dA = 0.005836 (should ≈ 1)\n", + " p(x|O_i) = 0.001158\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37261261261261264 (step_size_phi = 0.373\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.922097 (should = 1)\n", + " ∫ L(x-w) dA = 0.005847 (should ≈ 1)\n", + " p(x|O_i) = 0.001161\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.372972972972973 (step_size_phi = 0.373\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.923882 (should = 1)\n", + " ∫ L(x-w) dA = 0.005858 (should ≈ 1)\n", + " p(x|O_i) = 0.001163\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37333333333333335 (step_size_phi = 0.373\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.925668 (should = 1)\n", + " ∫ L(x-w) dA = 0.005869 (should ≈ 1)\n", + " p(x|O_i) = 0.001165\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3736936936936937 (step_size_phi = 0.374\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.927456 (should = 1)\n", + " ∫ L(x-w) dA = 0.005881 (should ≈ 1)\n", + " p(x|O_i) = 0.001167\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37405405405405406 (step_size_phi = 0.374\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.929245 (should = 1)\n", + " ∫ L(x-w) dA = 0.005892 (should ≈ 1)\n", + " p(x|O_i) = 0.001170\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3744144144144145 (step_size_phi = 0.374\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.931037 (should = 1)\n", + " ∫ L(x-w) dA = 0.005903 (should ≈ 1)\n", + " p(x|O_i) = 0.001172\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37477477477477483 (step_size_phi = 0.375\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.932830 (should = 1)\n", + " ∫ L(x-w) dA = 0.005915 (should ≈ 1)\n", + " p(x|O_i) = 0.001174\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3751351351351352 (step_size_phi = 0.375\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.934625 (should = 1)\n", + " ∫ L(x-w) dA = 0.005926 (should ≈ 1)\n", + " p(x|O_i) = 0.001176\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37549549549549555 (step_size_phi = 0.375\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.936421 (should = 1)\n", + " ∫ L(x-w) dA = 0.005938 (should ≈ 1)\n", + " p(x|O_i) = 0.001179\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3758558558558559 (step_size_phi = 0.376\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.938219 (should = 1)\n", + " ∫ L(x-w) dA = 0.005949 (should ≈ 1)\n", + " p(x|O_i) = 0.001181\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37621621621621626 (step_size_phi = 0.376\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.940019 (should = 1)\n", + " ∫ L(x-w) dA = 0.005960 (should ≈ 1)\n", + " p(x|O_i) = 0.001183\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3765765765765766 (step_size_phi = 0.377\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.941821 (should = 1)\n", + " ∫ L(x-w) dA = 0.005972 (should ≈ 1)\n", + " p(x|O_i) = 0.001185\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.376936936936937 (step_size_phi = 0.377\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.943624 (should = 1)\n", + " ∫ L(x-w) dA = 0.005983 (should ≈ 1)\n", + " p(x|O_i) = 0.001188\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37729729729729733 (step_size_phi = 0.377\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.945429 (should = 1)\n", + " ∫ L(x-w) dA = 0.005995 (should ≈ 1)\n", + " p(x|O_i) = 0.001190\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3776576576576577 (step_size_phi = 0.378\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.947236 (should = 1)\n", + " ∫ L(x-w) dA = 0.006006 (should ≈ 1)\n", + " p(x|O_i) = 0.001192\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37801801801801804 (step_size_phi = 0.378\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949045 (should = 1)\n", + " ∫ L(x-w) dA = 0.006018 (should ≈ 1)\n", + " p(x|O_i) = 0.001195\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3783783783783784 (step_size_phi = 0.378\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.950855 (should = 1)\n", + " ∫ L(x-w) dA = 0.006029 (should ≈ 1)\n", + " p(x|O_i) = 0.001197\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37873873873873876 (step_size_phi = 0.379\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.952667 (should = 1)\n", + " ∫ L(x-w) dA = 0.006041 (should ≈ 1)\n", + " p(x|O_i) = 0.001199\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3790990990990991 (step_size_phi = 0.379\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.954481 (should = 1)\n", + " ∫ L(x-w) dA = 0.006052 (should ≈ 1)\n", + " p(x|O_i) = 0.001201\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.37945945945945947 (step_size_phi = 0.379\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956296 (should = 1)\n", + " ∫ L(x-w) dA = 0.006064 (should ≈ 1)\n", + " p(x|O_i) = 0.001204\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3798198198198199 (step_size_phi = 0.380\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958113 (should = 1)\n", + " ∫ L(x-w) dA = 0.006075 (should ≈ 1)\n", + " p(x|O_i) = 0.001206\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38018018018018024 (step_size_phi = 0.380\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.959932 (should = 1)\n", + " ∫ L(x-w) dA = 0.006087 (should ≈ 1)\n", + " p(x|O_i) = 0.001208\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3805405405405406 (step_size_phi = 0.381\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.961753 (should = 1)\n", + " ∫ L(x-w) dA = 0.006098 (should ≈ 1)\n", + " p(x|O_i) = 0.001211\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38090090090090095 (step_size_phi = 0.381\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.963575 (should = 1)\n", + " ∫ L(x-w) dA = 0.006110 (should ≈ 1)\n", + " p(x|O_i) = 0.001213\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3812612612612613 (step_size_phi = 0.381\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.925208 (should = 1)\n", + " ∫ L(x-w) dA = 2.716502 (should ≈ 1)\n", + " p(x|O_i) = 0.771735\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38162162162162167 (step_size_phi = 0.382\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.926958 (should = 1)\n", + " ∫ L(x-w) dA = 2.721640 (should ≈ 1)\n", + " p(x|O_i) = 0.773194\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.381981981981982 (step_size_phi = 0.382\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.928710 (should = 1)\n", + " ∫ L(x-w) dA = 2.726782 (should ≈ 1)\n", + " p(x|O_i) = 0.774655\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3823423423423424 (step_size_phi = 0.382\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.930463 (should = 1)\n", + " ∫ L(x-w) dA = 2.731930 (should ≈ 1)\n", + " p(x|O_i) = 0.776117\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38270270270270274 (step_size_phi = 0.383\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.932217 (should = 1)\n", + " ∫ L(x-w) dA = 2.737082 (should ≈ 1)\n", + " p(x|O_i) = 0.777581\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3830630630630631 (step_size_phi = 0.383\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.933974 (should = 1)\n", + " ∫ L(x-w) dA = 2.742239 (should ≈ 1)\n", + " p(x|O_i) = 0.779046\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38342342342342345 (step_size_phi = 0.383\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.935732 (should = 1)\n", + " ∫ L(x-w) dA = 2.747401 (should ≈ 1)\n", + " p(x|O_i) = 0.780513\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3837837837837838 (step_size_phi = 0.384\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.937492 (should = 1)\n", + " ∫ L(x-w) dA = 2.752567 (should ≈ 1)\n", + " p(x|O_i) = 0.781980\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38414414414414416 (step_size_phi = 0.384\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.939253 (should = 1)\n", + " ∫ L(x-w) dA = 2.757739 (should ≈ 1)\n", + " p(x|O_i) = 0.783450\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3845045045045045 (step_size_phi = 0.385\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.941016 (should = 1)\n", + " ∫ L(x-w) dA = 2.762915 (should ≈ 1)\n", + " p(x|O_i) = 0.784920\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3848648648648649 (step_size_phi = 0.385\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.942781 (should = 1)\n", + " ∫ L(x-w) dA = 2.768097 (should ≈ 1)\n", + " p(x|O_i) = 0.786392\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3852252252252253 (step_size_phi = 0.385\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.944547 (should = 1)\n", + " ∫ L(x-w) dA = 2.773283 (should ≈ 1)\n", + " p(x|O_i) = 0.787865\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38558558558558564 (step_size_phi = 0.386\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.946315 (should = 1)\n", + " ∫ L(x-w) dA = 2.778474 (should ≈ 1)\n", + " p(x|O_i) = 0.789340\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.385945945945946 (step_size_phi = 0.386\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.948085 (should = 1)\n", + " ∫ L(x-w) dA = 2.783670 (should ≈ 1)\n", + " p(x|O_i) = 0.790816\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38630630630630636 (step_size_phi = 0.386\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.949856 (should = 1)\n", + " ∫ L(x-w) dA = 2.788870 (should ≈ 1)\n", + " p(x|O_i) = 0.792294\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3866666666666667 (step_size_phi = 0.387\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.951629 (should = 1)\n", + " ∫ L(x-w) dA = 2.794076 (should ≈ 1)\n", + " p(x|O_i) = 0.793773\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38702702702702707 (step_size_phi = 0.387\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.953404 (should = 1)\n", + " ∫ L(x-w) dA = 2.799286 (should ≈ 1)\n", + " p(x|O_i) = 0.795253\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3873873873873874 (step_size_phi = 0.387\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.955180 (should = 1)\n", + " ∫ L(x-w) dA = 2.804502 (should ≈ 1)\n", + " p(x|O_i) = 0.796734\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3877477477477478 (step_size_phi = 0.388\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.956958 (should = 1)\n", + " ∫ L(x-w) dA = 2.809722 (should ≈ 1)\n", + " p(x|O_i) = 0.798217\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38810810810810814 (step_size_phi = 0.388\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.958737 (should = 1)\n", + " ∫ L(x-w) dA = 2.814947 (should ≈ 1)\n", + " p(x|O_i) = 0.799702\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3884684684684685 (step_size_phi = 0.388\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.960518 (should = 1)\n", + " ∫ L(x-w) dA = 2.820176 (should ≈ 1)\n", + " p(x|O_i) = 0.801188\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38882882882882885 (step_size_phi = 0.389\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.962301 (should = 1)\n", + " ∫ L(x-w) dA = 2.825411 (should ≈ 1)\n", + " p(x|O_i) = 0.802675\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3891891891891892 (step_size_phi = 0.389\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.964086 (should = 1)\n", + " ∫ L(x-w) dA = 2.830651 (should ≈ 1)\n", + " p(x|O_i) = 0.804163\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.38954954954954957 (step_size_phi = 0.390\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.965872 (should = 1)\n", + " ∫ L(x-w) dA = 2.835895 (should ≈ 1)\n", + " p(x|O_i) = 0.805653\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3899099099099099 (step_size_phi = 0.390\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.967660 (should = 1)\n", + " ∫ L(x-w) dA = 2.841144 (should ≈ 1)\n", + " p(x|O_i) = 0.807144\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3902702702702703 (step_size_phi = 0.390\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.969449 (should = 1)\n", + " ∫ L(x-w) dA = 2.846398 (should ≈ 1)\n", + " p(x|O_i) = 0.808637\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3906306306306307 (step_size_phi = 0.391\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.971240 (should = 1)\n", + " ∫ L(x-w) dA = 2.851657 (should ≈ 1)\n", + " p(x|O_i) = 0.810131\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39099099099099105 (step_size_phi = 0.391\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.973033 (should = 1)\n", + " ∫ L(x-w) dA = 2.856921 (should ≈ 1)\n", + " p(x|O_i) = 0.811626\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3913513513513514 (step_size_phi = 0.391\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.974828 (should = 1)\n", + " ∫ L(x-w) dA = 2.862190 (should ≈ 1)\n", + " p(x|O_i) = 0.813123\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39171171171171176 (step_size_phi = 0.392\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.976624 (should = 1)\n", + " ∫ L(x-w) dA = 2.867463 (should ≈ 1)\n", + " p(x|O_i) = 0.814621\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3920720720720721 (step_size_phi = 0.392\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.978421 (should = 1)\n", + " ∫ L(x-w) dA = 2.872742 (should ≈ 1)\n", + " p(x|O_i) = 0.816121\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3924324324324325 (step_size_phi = 0.392\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.980221 (should = 1)\n", + " ∫ L(x-w) dA = 2.878025 (should ≈ 1)\n", + " p(x|O_i) = 0.817622\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39279279279279283 (step_size_phi = 0.393\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.982022 (should = 1)\n", + " ∫ L(x-w) dA = 2.883313 (should ≈ 1)\n", + " p(x|O_i) = 0.819124\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3931531531531532 (step_size_phi = 0.393\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.983825 (should = 1)\n", + " ∫ L(x-w) dA = 2.888606 (should ≈ 1)\n", + " p(x|O_i) = 0.820628\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39351351351351355 (step_size_phi = 0.394\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.899081 (should = 1)\n", + " ∫ L(x-w) dA = 0.002245 (should ≈ 1)\n", + " p(x|O_i) = 0.000430\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3938738738738739 (step_size_phi = 0.394\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.900728 (should = 1)\n", + " ∫ L(x-w) dA = 0.002249 (should ≈ 1)\n", + " p(x|O_i) = 0.000430\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39423423423423426 (step_size_phi = 0.394\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.902377 (should = 1)\n", + " ∫ L(x-w) dA = 0.002253 (should ≈ 1)\n", + " p(x|O_i) = 0.000431\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3945945945945946 (step_size_phi = 0.395\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.904027 (should = 1)\n", + " ∫ L(x-w) dA = 0.002257 (should ≈ 1)\n", + " p(x|O_i) = 0.000432\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.394954954954955 (step_size_phi = 0.395\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.905679 (should = 1)\n", + " ∫ L(x-w) dA = 0.002261 (should ≈ 1)\n", + " p(x|O_i) = 0.000433\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39531531531531533 (step_size_phi = 0.395\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.907333 (should = 1)\n", + " ∫ L(x-w) dA = 0.002265 (should ≈ 1)\n", + " p(x|O_i) = 0.000434\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39567567567567574 (step_size_phi = 0.396\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.908988 (should = 1)\n", + " ∫ L(x-w) dA = 0.002269 (should ≈ 1)\n", + " p(x|O_i) = 0.000434\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3960360360360361 (step_size_phi = 0.396\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.910644 (should = 1)\n", + " ∫ L(x-w) dA = 0.002274 (should ≈ 1)\n", + " p(x|O_i) = 0.000435\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39639639639639646 (step_size_phi = 0.396\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.912302 (should = 1)\n", + " ∫ L(x-w) dA = 0.002278 (should ≈ 1)\n", + " p(x|O_i) = 0.000436\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3967567567567568 (step_size_phi = 0.397\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.913962 (should = 1)\n", + " ∫ L(x-w) dA = 0.002282 (should ≈ 1)\n", + " p(x|O_i) = 0.000437\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39711711711711717 (step_size_phi = 0.397\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.915623 (should = 1)\n", + " ∫ L(x-w) dA = 0.002286 (should ≈ 1)\n", + " p(x|O_i) = 0.000438\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3974774774774775 (step_size_phi = 0.397\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.917285 (should = 1)\n", + " ∫ L(x-w) dA = 0.002290 (should ≈ 1)\n", + " p(x|O_i) = 0.000438\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3978378378378379 (step_size_phi = 0.398\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.918949 (should = 1)\n", + " ∫ L(x-w) dA = 0.002294 (should ≈ 1)\n", + " p(x|O_i) = 0.000439\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39819819819819824 (step_size_phi = 0.398\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.920615 (should = 1)\n", + " ∫ L(x-w) dA = 0.002298 (should ≈ 1)\n", + " p(x|O_i) = 0.000440\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3985585585585586 (step_size_phi = 0.399\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.922282 (should = 1)\n", + " ∫ L(x-w) dA = 0.002303 (should ≈ 1)\n", + " p(x|O_i) = 0.000441\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39891891891891895 (step_size_phi = 0.399\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.923950 (should = 1)\n", + " ∫ L(x-w) dA = 0.002307 (should ≈ 1)\n", + " p(x|O_i) = 0.000441\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.3992792792792793 (step_size_phi = 0.399\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.925620 (should = 1)\n", + " ∫ L(x-w) dA = 0.002311 (should ≈ 1)\n", + " p(x|O_i) = 0.000442\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.39963963963963967 (step_size_phi = 0.400\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.927292 (should = 1)\n", + " ∫ L(x-w) dA = 0.002315 (should ≈ 1)\n", + " p(x|O_i) = 0.000443\n", + "=======================================================\n", + "\n", + "\n", + "=======================================================\n", + " phi_cand = 1.0\" r = 0.5\" a = 0.1\" b = 0.05\"\n", + " step_size = 0.4 (step_size_phi = 0.400\")\n", + " Integration box half-width: 6.0\"\n", + " ∫ p(w|O_i) dA = 0.928965 (should = 1)\n", + " ∫ L(x-w) dA = 0.002319 (should ≈ 1)\n", + " p(x|O_i) = 0.000444\n", + "=======================================================\n", + "\n" + ] + } + ], + "source": [ + "# Now let's iterate through different step_sizes for this scenario to determine \n", + "# the error for each size\n", + "# step_sizes = np.logspace(-3, -1, 100)\n", + "step_size_max_old = 2 * 3 * np.nanmin([a, b]) / np.nanmax(phi_cand)\n", + "step_size_max_new = np.nanmin([a, b]) / np.nanmax(phi_cand)\n", + "mmin = step_size_max_new - 0.01\n", + "mmax = step_size_max_old + 0.1\n", + "step_sizes = np.linspace(mmin, mmax, 1000)\n", + "pws = []\n", + "Ls = []\n", + "p_xOis = []\n", + "for step_size in step_sizes:\n", + " g = build_grids(phi_cand, r, a, b, theta_prior, step_size, pa_deg)\n", + " pws.append(g['check_pw'])\n", + " Ls.append(g['check_L'])\n", + " p_xOis.append(g['p_xOi'])\n", + " \n", + " print(f\"\\n{'='*55}\")\n", + " print(f\" phi_cand = {phi_cand}\\\" r = {r}\\\" a = {a}\\\" b = {b}\\\"\")\n", + " print(f\" step_size = {step_size} (step_size_phi = {g['step_size_phi']:.3f}\\\")\")\n", + " print(f\" Integration box half-width: {g['box_hwidth']:.1f}\\\"\")\n", + " print(f\" ∫ p(w|O_i) dA = {g['check_pw']:.6f} (should = 1)\")\n", + " print(f\" ∫ L(x-w) dA = {g['check_L']:.6f} (should ≈ 1)\")\n", + " print(f\" p(x|O_i) = {g['p_xOi']:.6f}\")\n", + " print(f\"{'='*55}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "f3ce5489", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, '100 by 50 mas, ang_size = 1.0\"')" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(10,6))\n", + "cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']\n", + "\n", + "plt.scatter(step_sizes, pws, s=10, color=cycle[0], label=r'$p(w|O_i) \\sim 1$')\n", + "plt.scatter(step_sizes, Ls, s=10, color=cycle[1], label=r'$L(x{-}w) \\sim 1$')\n", + "plt.scatter(step_sizes, p_xOis, s=10, color=cycle[2], label=r'$p(x|O_i)$')\n", + "plt.axvline(x=step_size_max_old, color='black', linestyle='dashed', lw=2, label='step_size_max = 6 * min(a,b) / max(phi)')\n", + "plt.axvline(x=step_size_max_new, color='black', lw=2, label='step_size_max = min(a,b) / max(phi)')\n", + "plt.grid()\n", + "plt.xlabel(r'step_size (fraction of $\\phi$)')\n", + "plt.ylabel('Integrated Value')\n", + "plt.legend(fontsize=15)\n", + "plt.xlim([mmin, mmax])\n", + "plt.title(f'{int(1000*a):d} by {int(1000*b):d} mas, ang_size = {phi_cand:.1f}\"')" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "5bdb27b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.30000000000000004 0.05\n" + ] + } + ], + "source": [ + "print(step_size_max_old, step_size_max_new)" + ] + }, + { + "cell_type": "markdown", + "id": "c8a4759d", + "metadata": {}, + "source": [ + "## Question 2: How should we set `step_size` based on `a`, `b`, and `ang_size`?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1aafaa95", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/calculations/step_size/test_accuracy.py b/calculations/step_size/test_accuracy.py new file mode 100644 index 0000000..e3a57d1 --- /dev/null +++ b/calculations/step_size/test_accuracy.py @@ -0,0 +1,310 @@ +""" Test the accuracy of the step size for the +localization and galaxy convolution. +""" + +# imports +import os + +import numpy as np +import matplotlib.pyplot as plt +#import pandas + +from astropy.coordinates import SkyCoord +from astropy.coordinates import offset_by +from astropy import units +#from astropy.io import fits + +from astropath import path +from astropath import localization +from astropath import bayesian + +theta_prior = dict(max=6., PDF='exp', scale=1.) + + +def set_fontsize(ax, fsz): + """ + Set the fontsize throughout an Axis + + Args: + ax (Matplotlib Axis): + fsz (float): Font size + + Returns: + + """ + for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] + + ax.get_xticklabels() + ax.get_yticklabels()): + item.set_fontsize(fsz) + +def init_localization(a, b): + + Path = path.PATH() + frb_coord = SkyCoord('21h44m25.255s -40d54m00.10s', frame='icrs') + eellipse = dict(a=a, b=b, theta=0.) + + Path.init_localization('eellipse', + center_coord=frb_coord, + eellipse=eellipse) + + return Path + +def single_case(outfile:str, a, b, galaxy_size, + gal_offset:float=3., step_sizes=None, + gal_pa:float=0.): + + box_hwidth = max(5 * a, gal_offset + 6 * galaxy_size) # arcsec + + # FRB + path = init_localization(a, b) + + # Galaxy + gal_coord = path.localiz['center_coord'].directional_offset_by( + gal_pa*units.deg, gal_offset*units.arcsec) + + # Step sizes + if step_sizes is None: + step_sizes = np.array([0.02, 0.05, 0.1, 0.2, 0.5, 1., 2.]) # fast + + raw_pxO = np.zeros((1, len(step_sizes))) + cor_pxO = np.zeros((1, len(step_sizes))) + + # Prescription + best_step = max(b, galaxy_size)/20. + + for ss in [0]: + + # Loop on step size + for ii, step_size in enumerate(step_sizes): + print(f'Step size: {step_size}') + + # Calculate + L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid( + box_hwidth, path.localiz, np.array([gal_coord]), + np.array([galaxy_size]), theta_prior, step_size=step_size, + return_debug=True) + + # Save + raw_pxO[ss, ii] = p_xOis + + # Correction + if b > galaxy_size: + cor_pxO[ss, ii] = p_xOis / np.sum(p_wOi) / step_size**2 + else: + cor_pxO[ss, ii] = p_xOis / np.sum(L_wx) / step_size**2 + #assert (np.sum(L_wx) * step_size**2) > 0.98, f'L_wx: {np.sum(L_wx) * step_size**2}' + + # Normalize by the first step size + for ss in [0]: + cor_pxO[ss, :] /= cor_pxO[ss, 0] + raw_pxO[ss, :] /= raw_pxO[ss, 0] + + title = f'Localization, a={a}", b={b}; offset by {gal_offset}"; PA={gal_pa}"' + plot_results(outfile, raw_pxO, cor_pxO, + np.array([galaxy_size]), step_sizes, best_step, + var_name='Galaxy size', title=title) + +def big_galaxy(galaxy_size:float=20.): + + box_hwidth = 6 * galaxy_size # arcsec + + # FRB + frb_coord = SkyCoord('21h44m25.255s -40d54m00.10s', frame='icrs') + + # Galaxy + gal_coord = frb_coord.directional_offset_by( + 0.*units.deg, 3.0*units.arcsec) + + # Loop on FRB sizes + frb_sizes = np.array([0.1, 0.5, 1.0, 5.]) + + #step_sizes = np.array([0.01, 0.05, 0.1, 0.2, 0.5, 1.]) + step_sizes = np.array([0.05, 0.1, 0.2, 0.5, 1., 2.]) # fast + + raw_pxO = np.zeros((len(frb_sizes), len(step_sizes))) + cor_pxO = np.zeros((len(frb_sizes), len(step_sizes))) + + for ss, frb_size in enumerate(frb_sizes): + + # Loop on step size + for ii, step_size in enumerate(step_sizes): + print(f'FRB size: {frb_size}, Step size: {step_size}') + + # FRB + path = init_localization(frb_size, frb_size) + + # Calculate + L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid( + box_hwidth, path.localiz, np.array([gal_coord]), + np.array([galaxy_size]), theta_prior, + step_size=step_size, + return_debug=True) + + # Save + raw_pxO[ss, ii] = p_xOis + cor_pxO[ss, ii] = p_xOis / np.sum(L_wx) / step_size**2 + # Another correction + #cor_pxO[ss, ii] = cor_pxO[ss,ii] / np.sum(p_wOi) / step_size**2 + + #assert (np.sum(L_wx) * step_size**2) > 0.98, f'L_wx: {np.sum(L_wx) * step_size**2}' + + # Normalize by the first step size + for ss in range(len(frb_sizes)): + cor_pxO[ss, :] /= cor_pxO[ss, 0] + raw_pxO[ss, :] /= raw_pxO[ss, 0] + + # Plot + outfile = 'big_galaxy.png' + title = f'Big Galaxy, {galaxy_size}"' + plot_results(outfile, raw_pxO, cor_pxO, + frb_sizes, step_sizes, galaxy_size/20, + var_name='FRB size', title=title) + +def big_localization(frb_local:float=20.): + + # FRB + path = init_localization(frb_local, frb_local) + box_hwidth = 5 * frb_local # arcsec + + # Galaxy + gal_coord = path.localiz['center_coord'].directional_offset_by( + 0.*units.deg, 1.0*units.arcsec) + + # Loop on galaxy size + gal_sizes = np.array([0.1, 0.5, 1.0, 5.]) + + #step_sizes = np.array([0.01, 0.05, 0.1, 0.2, 0.5, 1.]) + step_sizes = np.array([0.05, 0.1, 0.2, 0.5, 1., 2.]) # fast + + raw_pxO = np.zeros((len(gal_sizes), len(step_sizes))) + cor_pxO = np.zeros((len(gal_sizes), len(step_sizes))) + + for ss, gal_size in enumerate(gal_sizes): + + # Loop on step size + for ii, step_size in enumerate(step_sizes): + print(f'Galaxy size: {gal_size}, Step size: {step_size}') + + # Calculate + L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid( + box_hwidth, path.localiz, np.array([gal_coord]), + np.array([gal_size]), theta_prior, step_size=step_size, + return_debug=True) + + # Save + raw_pxO[ss, ii] = p_xOis + cor_pxO[ss, ii] = p_xOis / np.sum(p_wOi) / step_size**2 + #assert (np.sum(L_wx) * step_size**2) > 0.98, f'L_wx: {np.sum(L_wx) * step_size**2}' + + # Normalize by the first step size + for ss in range(len(gal_sizes)): + cor_pxO[ss, :] /= cor_pxO[ss, 0] + raw_pxO[ss, :] /= raw_pxO[ss, 0] + + # Plot + outfile = 'big_localization.png' + title = f'Big Localization, {frb_local}"' + plot_results(outfile, raw_pxO, cor_pxO, + gal_sizes, step_sizes, frb_local/20, + var_name='Galaxy size', title=title) + + +def gbo_localization(a=20., b=0.2): + + # FRB + path = init_localization(a, b) + box_hwidth = 5 * a # arcsec + + # Galaxy + gal_coord = path.localiz['center_coord'].directional_offset_by( + 0.*units.deg, 3.0*units.arcsec) + + # Loop on galaxy size + gal_sizes = np.array([0.1, 0.5, 1.0, 5.]) + + step_sizes = np.array([0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.]) + #step_sizes = np.array([0.05, 0.1, 0.2, 0.5, 1., 2.]) # fast + + raw_pxO = np.zeros((len(gal_sizes), len(step_sizes))) + cor_pxO = np.zeros((len(gal_sizes), len(step_sizes))) + + for ss, gal_size in enumerate(gal_sizes): + + # Loop on step size + for ii, step_size in enumerate(step_sizes): + print(f'Galaxy size: {gal_size}, Step size: {step_size}') + + # Calculate + L_wx, p_wOi, grid_p, p_xOis = bayesian.px_Oi_fixedgrid( + box_hwidth, path.localiz, np.array([gal_coord]), + np.array([gal_size]), theta_prior, step_size=step_size, + return_debug=True) + + # Save + raw_pxO[ss, ii] = p_xOis + cor_pxO[ss, ii] = p_xOis / np.sum(p_wOi) / step_size**2 + #assert (np.sum(L_wx) * step_size**2) > 0.98, f'L_wx: {np.sum(L_wx) * step_size**2}' + + # Normalize by the first step size + for ss in range(len(gal_sizes)): + cor_pxO[ss, :] /= cor_pxO[ss, 0] + raw_pxO[ss, :] /= raw_pxO[ss, 0] + + # Plot + outfile = 'gbo_localization.png' + title = f'GBO Localization, a={a}", b={b}"' + plot_results(outfile, raw_pxO, cor_pxO, + gal_sizes, step_sizes, 0.1, + var_name='Galaxy size', title=title) + +def plot_results(outfile:str, raw_pxO, cor_pxO, + var_sizes, step_sizes, + pref_step_size:float, + var_name:str='Galaxy size', + title:str=None): + + # Plot me + fig = plt.figure(figsize=(10, 5)) + ax = plt.gca() + + clrs = ['red', 'green', 'blue', 'purple'] + for ss, var_size in enumerate(var_sizes): + ax.plot(step_sizes, cor_pxO[ss, :], color=clrs[ss], + label=f'{var_name}: {var_size}') + ax.plot(step_sizes, raw_pxO[ss, :], ls=':', color=clrs[ss]) + + ax.legend(fontsize=15.) + ax.set_xlabel('Step size (arcsec)') + ax.set_ylabel('Normalized p_xO') + + if title is not None: + ax.set_title(title, fontsize=15.) + ax.set_xscale('log') + #ax.set_yscale('log') + #ax.grid(True) + ax.grid(which='major', linewidth=0.8, alpha=0.7) + ax.grid(which='minor', linewidth=0.5, alpha=0.3) + set_fontsize(ax, 15.) + + # Vertical line + ax.axvline(x=pref_step_size, color='black', + linewidth=0.8) + + ax.set_ylim(0.9, 1.1) + + plt.tight_layout() + plt.savefig(outfile, dpi=300) + print(f'Saved to {outfile}') + +# Command line +if __name__ == '__main__': + + #big_localization() + #big_galaxy() + #gbo_localization() + + # ############ + # Individual cases + #single_case('single_case.png', + # 5., 5., 2., gal_offset=7.) + single_case('single_case.png', + 20., 0.2, 2., gal_offset=2., gal_pa=90.) \ No newline at end of file diff --git a/docs/figures/profiling_local_timing.png b/docs/figures/profiling_local_timing.png new file mode 100644 index 0000000..e0ded67 Binary files /dev/null and b/docs/figures/profiling_local_timing.png differ diff --git a/docs/figures/profiling_timing.png b/docs/figures/profiling_timing.png new file mode 100644 index 0000000..b2ea4ef Binary files /dev/null and b/docs/figures/profiling_timing.png differ diff --git a/docs/frb_example.rst b/docs/frb_example.rst index c2ba214..e356717 100644 --- a/docs/frb_example.rst +++ b/docs/frb_example.rst @@ -94,4 +94,10 @@ Another simple call with the "fixed" approach:: P_Ox, P_Ux = Path.calc_posteriors('fixed', box_hwidth=30.) -And we are all done! \ No newline at end of file +And we are all done! + +.. note:: + + For large grids you can optionally accelerate the fixed-grid + calculation with ``numba`` (off by default; falls back to numpy if + ``numba`` is not installed). See :doc:`performance` for details. \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst index 88c81b7..298c026 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -64,6 +64,14 @@ Scripts scripts +Performance +----------- + +.. toctree:: + :maxdepth: 2 + + performance + Notebooks --------- diff --git a/docs/localization.rst b/docs/localization.rst index e1f7650..7efbdcc 100644 --- a/docs/localization.rst +++ b/docs/localization.rst @@ -32,6 +32,10 @@ The last line of code checks against the data model. The code then defines the localization PDF as a 2D Gaussian with sigma's "a" and "b" and orientation given by "theta". +The error-ellipse evaluation of :math:`L(w-x)` +(``localization.calc_LWx``) is implemented in pure numpy for speed; +see :doc:`performance`. + Healpix ======= diff --git a/docs/nb/FRB_example.ipynb b/docs/nb/FRB_example.ipynb index bfc0c0d..4b26f17 100644 --- a/docs/nb/FRB_example.ipynb +++ b/docs/nb/FRB_example.ipynb @@ -709,7 +709,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.14.5" } }, "nbformat": 4, diff --git a/docs/performance.rst b/docs/performance.rst new file mode 100644 index 0000000..af15aee --- /dev/null +++ b/docs/performance.rst @@ -0,0 +1,278 @@ +*********** +Performance +*********** + +This doc describes the performance-oriented pieces of *astropath*: +the numpy-accelerated core calculations, the optional ``numba`` +acceleration for the fixed-grid posterior, and the ``profiling`` +module used to measure them. + +numpy-accelerated core +====================== + +The two most expensive steps in a PATH analysis have been +re-implemented in pure numpy: + +- ``localization.calc_LWx`` (the localization term :math:`L(w-x)`) + for the error-ellipse (``eellipse``) localization now computes the + angular separation and position angle with closed-form numpy + formulae instead of ``astropy`` ``SkyCoord`` operations. Results are + numerically identical (to roundoff) and the routine is several times + faster on large grids. + +- ``bayesian.px_Oi_fixedgrid`` (the fixed-grid :math:`p(x|O_i)`) + pre-extracts the candidate and center coordinates into numpy arrays + once, rather than reading ``astropy`` attributes inside the + per-candidate loop. + +- ``bayesian.px_Oi_local`` (the local-grid :math:`p(x|O_i)`, which + builds one grid per candidate) has likewise been rewritten in pure + numpy for the ``eellipse`` localization: it pre-extracts the + coordinates once and evaluates :math:`L(w-x)` directly in a flat-sky + tangent plane, removing every ``astropy`` call from the per-candidate + loop. Other localization types (``healpix``, ``wcs``) fall back to + ``localization.calc_LWx`` as before. See `Local-grid posterior`_ + below for details. + +These changes are transparent: you do not need to do anything to +benefit from them, and the public APIs are unchanged. + +Optional numba acceleration +=========================== + +The per-candidate loop of ``bayesian.px_Oi_fixedgrid`` can optionally +be evaluated with a `numba `_ kernel +(``bayesian.px_Oi_numba``) that fuses the offset, offset-PDF, product +with :math:`L(w-x)`, and grid sum into a single pass with no full-grid +temporaries. + +To enable it, pass ``use_numba=True``:: + + from astropath import bayesian + + p_xOi = bayesian.px_Oi_fixedgrid( + box_hwidth, localiz, cand_coords, cand_ang_size, + theta_prior, step_size=0.1, use_numba=True) + +Key points: + +- **Optional.** ``numba`` need *not* be installed. If it is absent (or + if you simply leave ``use_numba=False``, the default), the + calculation runs via the standard numpy path. With ``use_numba=True`` + but ``numba`` not installed, the code emits a warning and falls back + to numpy — it never errors. + +- **Default is off.** ``use_numba`` defaults to ``False``, so existing + code and results are unchanged unless you opt in. + +- **Only ``px_Oi_fixedgrid``.** The numba option is available *only* + for the fixed-grid method. ``px_Oi_local`` and the other routines are + unaffected. The fused kernel returns only the scalar posterior, so it + is bypassed (numpy path used) when ``return_grids`` or + ``return_debug`` is requested. + +- **Primarily for sandbox analyses.** numba is recommended mainly for + interactive/sandbox work and large-grid experiments, where its + speed-up is largest. The first call pays a one-time JIT compilation + cost; the win grows with the grid size and the number of candidates + (roughly 1.5x on small grids up to ~5-6x on a 7200x7200 grid with + many candidates). + +.. note:: + + The numba flag is exposed on ``bayesian.px_Oi_fixedgrid`` directly. + The high-level ``path.PATH.calc_posteriors`` does not currently + forward ``use_numba``; call ``bayesian.px_Oi_fixedgrid`` directly to + use it. + +Local-grid posterior +==================== + +``bayesian.px_Oi_local`` evaluates :math:`p(x|O_i)` on a separate grid +per candidate, centered on the galaxy and sized to the offset prior +(``box_hwidth = phi*max``). It is the method of choice for +localizations that span a large area of sky, where +a single fixed grid would be prohibitively large. + +For the ``eellipse`` localization the calculation is pure numpy and +flat-sky: + +- The per-candidate grid is built once in normalized units and merely + rescaled per galaxy — the pixel count ``ngrid = 2*max/step_size`` is + the same for every candidate. + +- :math:`L(w-x)` is evaluated directly in the tangent plane (offsets + rotated into the ellipse frame), matching the spherical ``calc_LWx`` + to ~1e-5 fractionally at arcsec scales. + +Here ``step_size`` is *relative* to the galaxy size (default ``0.05``), +so the grid spacing is ``phi*step_size``. + +.. note:: + + ``px_Oi_local`` is **pure numpy and does not require (or use) + numba** — for now. The optional numba acceleration described above + applies only to ``px_Oi_fixedgrid``. ``px_Oi_local`` is fast on its + own because each per-candidate grid is small. + +Small-localization correction +------------------------------ + +When the localization minor axis :math:`b` is smaller than the galaxy +angular size :math:`\phi`, the galaxy-centered grid under-resolves the +sharp localization and the raw sum is biased low. In that case +``px_Oi_local`` divides the result by a correction factor computed by +``bayesian._Lwx_correction``: the discrete "total :math:`L(w-x)`" on a +small grid that is centered on the localization and *aligned to the +galaxy grid* (same spacing, shifted by an integer number of cells). +Because the localization is sampled at the same sub-cell phase in the +raw sum and in this factor, the under-resolution bias cancels in the +ratio (accurate to ~1%). This is the local analogue of +``px_Oi_fixedgrid``'s ``correction='L_wx'``. The correction grid is +bounded (it is skipped when it would exceed ~5000 cells per side, which +only happens when the localization is already well resolved and no +correction is needed), so it never allocates a large array. + +Profiling module +================ + +The ``astropath.profiling`` module measures these calculations across a +range of grid sizes. It mirrors the +``calculations/step_size/Profiling.ipynb`` notebook: a faux FRB, a +circular error ellipse, and a set of candidate galaxies spread over a +range of locations and angular sizes. + +Run it from the command line:: + + python -m astropath.profiling + +This sweeps a range of ``step_size`` values (hence grid sizes) and +profiles both posterior methods: + +- ``calc_LWx``, the numpy ``px_Oi_fixedgrid``, and (if ``numba`` is + installed) the numba path with its speed-up factor — written to + ``profiling_timing.png``; + +- ``px_Oi_local`` (via ``run_profiling_local``), whose per-candidate + grid size is ``2*max/step_size`` — written to + ``profiling_local_timing.png``. + +Both timing tables are printed to the screen. + +You can also import and call the pieces directly:: + + from astropath import profiling + + df = profiling.run_profiling() # fixed-grid (+ numba) + profiling.plot_results(df, 'timing.png') + + df_local = profiling.run_profiling_local() # local-grid method + profiling.plot_local_results(df_local, 'local.png') + +Benchmark results +================= + +Accuracy +-------- + +``px_Oi_local`` is validated against ``px_Oi_fixedgrid`` run on a fine +grid (the ``astropath/tests/tests_local.py`` module). Both evaluate the +same integral :math:`p(x|O_i)=\int L(w-x)\,p(w|O_i)\,dw`; the fine fixed +grid is taken as truth. Across the size regimes the local method +reproduces it to a fraction of a percent (run at ``step_size=0.02``): + +.. csv-table:: px_Oi_local vs fine fixed grid (step_size = 0.02) + :header: "Case", "localization", "galaxy", "rel. diff" + :widths: 30, 18, 10, 12 + + "large galaxy / small loc", "a=b=1″", "10″", "+7.0e-5" + "large galaxy / large loc", "a=b=10″", "10″", "-3.3e-3" + "small galaxy / small loc", "a=b=1″", "1″", "-3.3e-3" + "small galaxy / large loc", "a=b=10″", "1″", "-3.3e-3" + "small galaxy / ellipse", "a=10″, b=0.2″", "0.5″", "-3.3e-3" + +When the localization minor axis is smaller than the galaxy +(:math:`b<\phi`) the ``_Lwx_correction`` removes the O(step) bias, so the +result stays accurate even at coarse (galaxy-relative) step sizes where +the uncorrected sum would be off by ~1-2 %: + +.. csv-table:: L_wx correction (b < phi), corrected rel. diff vs raw + :header: "Case", "step", "raw (no corr.)", "corrected" + :widths: 26, 8, 16, 12 + + "gal 10″ / loc a=b=1″", "0.05", "-0.85 %", "-1.7e-4" + "gal 10″ / loc a=b=1″", "0.10", "-1.85 %", "-1.9e-3" + "ellipse a=10″, b=0.2″", "0.05", "-0.84 %", "-7.1e-6" + "ellipse a=10″, b=0.2″", "0.10", "-1.66 %", "+3.4e-5" + +Even for a very small (sub-arcsec) localization, where the galaxy grid +badly under-resolves the localization, the correction recovers the fine +fixed-grid value (``step_size=0.05``): + +.. csv-table:: Very small localization (a=b=0.1") + :header: "galaxy", "rel. diff" + :widths: 12, 12 + + "0.3″", "+6.9e-5" + "0.6″", "+2.5e-5" + "1.0″", "+4.8e-5" + +Profiling +--------- + +Timings below were produced by ``python -m astropath.profiling`` (50 +candidate galaxies; absolute times are machine-dependent, the trends and +ratios are the point). + +**Fixed-grid posterior** (``px_Oi_fixedgrid``): the numba path overtakes +numpy beyond small grids, reaching ~5-6x on the largest grids; the +one-off JIT cost makes it slower than numpy only on the smallest grid. + +.. csv-table:: px_Oi_fixedgrid timing (50 candidates) + :header: "step", "grid", "calc_LWx", "numpy", "numba", "numba speed-up" + :widths: 8, 12, 10, 12, 10, 14 + + "0.50", "360²", "9 ms", "30 ms", "145 ms", "0.2x" + "0.25", "720²", "42 ms", "173 ms", "91 ms", "1.9x" + "0.10", "1800²", "344 ms", "2.06 s", "670 ms", "3.1x" + "0.05", "3600²", "1.67 s", "16.4 s", "2.96 s", "5.6x" + "0.025", "7200²", "6.49 s", "68.5 s", "12.4 s", "5.5x" + +.. figure:: figures/profiling_timing.png + :width: 90 % + :align: center + + Fixed-grid timing vs grid side length (sqrt of pixels). The dashed + line marks 10 s. + +**Local-grid posterior** (``px_Oi_local``): the cost depends on the +localization. With no correction (circular, :math:`b\ge\phi`) or a tiny +localization (a=b=0.1", small correction grid) the per-candidate cost is +modest; a long thin ellipse (a=12.5", b=0.2") drives the correction grid +to ~1000² and dominates the run time -- i.e. the correction cost scales +with the localization major axis. + +.. csv-table:: px_Oi_local timing (50 candidates), milliseconds + :header: "step", "galaxy grid", "ellipse corr grid", "circular", "ellipse", "small loc" + :widths: 7, 12, 16, 10, 10, 10 + + "0.50", "24²", "97²", "0.9", "6.8", "2.3" + "0.25", "48²", "197²", "1.8", "22", "3.3" + "0.10", "120²", "497²", "7.9", "146", "11" + "0.05", "240²", "997²", "31", "1553", "41" + "0.025", "480²", "1997²", "155", "9037", "185" + +.. figure:: figures/profiling_local_timing.png + :width: 90 % + :align: center + + Local-grid timing vs per-candidate galaxy-grid side length, for the + three localization scenarios. The dashed line marks 10 s. + +API Reference +============= + +.. automodule:: astropath.profiling + :members: + :undoc-members: + :show-inheritance: diff --git a/prompts/speed_up_fixed.md b/prompts/speed_up_fixed.md new file mode 100644 index 0000000..bc4740b --- /dev/null +++ b/prompts/speed_up_fixed.md @@ -0,0 +1,828 @@ +# Speeding up the PATH calculations + +## Goals + +This document is a collection of ideas and prompts for speeding up the PATH calculations. + +## Coding + +Here are guidelines for coding: + +- Use Python where possible +- Add inline comments to explain the effort +- Reuse existing code when possible +- Place import statements at the top of the file. +- Include a description of inputs/outputs in the doc string of all methods +- Use lines of code that are less than 80 characters wide + +## Running + +If you need to run python, use the "astro14" environment. + +## Development + +### calc_LWx + +We wish to speed up the calculation of L(w-x) for a given localization. + +1. Speed up the code in localization.py:calc_LWx that calculates the grid of L(w-x) values for a given localization with the eellipse type. Please: + +- Examine the code +- Identify the bottlenecks +- Figure out how to replace all astropy calculations +- Log your work in the "Logs" section below. +- Make recommendations +- Do not generate any new code yet +- If you have any questions, ask them in the Logs and I will clarify at my next prompt + +2. Write new code to replace the astropy calculations with numpy calculations. Please: + +- Replace the astropy calculations with numpy calculations as described in the Logs. +- Keep the existing astropy code as a test case. +- Stick with calc_Lwx for now; we will revisit px_Oi_local later. +- Generate a new test case to verify the new code. Make a test_speed_up.py module and model it after the other modules in astropath/tests. +- Have the tests also compare and report the speed up +- Include the timing for a grid that is 7200x7200 pixels +- Log your work in the "Logs" section below. + +### px_Oi_fixedgrid + +We wish to speed up the calculation of p(x|O_i) for a given localization using the fixed grid method. + +1. Similar to the calc_LWx bottlenecks, we need to identify the bottlenecks and replace the astropy calculations with numpy calculations. Please: + +- Examine the code +- Identify the bottlenecks +- Figure out how to replace all astropy calculations +- If it would help to store ra, dec in radians and not deg consider it +- Log your work in the "Logs" section below. +- Make recommendations +- Do not generate any new code yet +- If you have any questions, ask them in the Logs and I will clarify at my next prompt + +2. Write new code to replace the astropy calculations with numpy calculations. Please: + +- Replace the astropy calculations with numpy calculations as described in the Logs. +- Generate new tests and add them to the test_speed_up.py module. +- Only implement items 1 and 2 in the Logs; no vectorization or other optimizations yet +- We may try to speed things up further with numba. Consider that in your programming +- Log your work in the "Logs" section below. + +## Profiling + +1. Generate a module to profile the code. Call it profiling.py and place it in the astropath directory. At this stage, we wish to profile the code for the calc_LWx and px_Oi_fixedgrid methods. Please: + +- Model the code after the Profiling.ipynb notebook in the astropath/calculations/step_size directory +- Run on a range of grid sizes by varying the step_size +- Generate a table of the timing results. Print these to the screen +- Generate a figure of the timing results +- Log your work in the "Logs" section below. + +2. Modify the profiling.py tests to: + +- Run on N=50 candidates instead of only 2. Have the galaxies have a range of anuglar sizes and locations +- Use red, and not orange for px_Oi_fixedgrid +- Instead of pixels, label the x-axis in sqrt(pixels) + +3. I have added the px_Oi_numba method to the bayesian.py file. Please: + +- Update the profiling.py tests to use the px_Oi_numba method +- Report back on the speed up +- Include a new curve on the figure for when using numba +- Log your work in the "Logs" section below. + +4. Make these changes to profiling.py: + +- Add a few print statements to the profiling.py module to report on progress +- Add a dark grey horiztonal line at 10s on the figure +- You do not need to Log these changes + +5. Make these changes to profiling.py: + +- Include the JIT warm-up as part of the timing +- Have it be the default option to call px_Oi_fixedgrid() with correction='p_wO' +- Log your work in the "Logs" section below. + +## Numba + +We will use numba to speed up the code. This will mainly be for sandbox analyses. + +### px_Oi_fixedgrid + +1. Examine the code for px_Oi_fixedgrid. We will use numba ot speed up the main loop. Please: + +- Examine the code +- Develop a plan to introduce numba +- Try to keep the pw_Oi() method separate from px_Oi_fixedgrid() +- Log your work in the "Logs" section below. +- If you have any questions, ask them in the Logs and I will clarify at my next prompt +- Do not generate any new code yet + +2. Proceed with generating a numba option for the main loop. Please: + +- Make numba optional. It need not be installed, although I have just done so in the astro14 environment. +- Have use_numba be a boolean flag for the method that is set to False by default. +- It is ok to single-source the *norm* +- Start with single-threaded @njit +- Perform your validation plan using the test_speed_up.py module. +- Log your work in the "Logs" section below. + +3. I have made a changes to the px_Oi_fixedgrid method to implement an optional correction factor. Please: + +- Update the numba version to implement the same correction factor as the numpy version +- Test these changes +- Log your work in the "Logs" section below. + +## Docs + +1. Examine the docs in the astropath/docs directory. We need to update the documentation to reflect the new code and the numba option. Please: + +- Update the documentation to reflect the new code and the numba option. +- Emphasize that the numba option is optional and that the code will fall back to the numpy option if numba is not installed or if the user does not set use_numba to True. +- Comment that the numba option is only available for the px_Oi_fixedgrid method. +- Add that it is primarily recommended for sandbox analyses. +- Comment on the profiling.py module too +- Log your work in the "Logs" section below. + +## Prompts + +1. Read this doc. Proceed with the 1st item under Development/calc_LWx +2. Read this doc. Proceed with the 2nd item under Development/calc_LWx +3. Read this doc. Proceed with the 1st item under Development/px_Oi_fixedgrid +4. Read this doc. Proceed with the 2nd item under Development/px_Oi_fixedgrid +5. Read this doc. Proceed with the 1st item under Development/Profiling +6. Read this doc. Proceed with the 2nd item under Development/Profiling +7. Read this doc. Proceed with the 1st item under Numba/px_Oi_fixedgrid +8. Read this doc. Proceed with the 2nd item under Numba/px_Oi_fixedgrid +9. Read this doc. Proceed with the 3rd item under Development/Profiling +10. Read this doc. Proceed with the 4th item under Development/Profiling +11. Read this doc. Proceed with the 1st item under Docs +12. Read this doc. Proceed with the 3rd item under Numba/px_Oi_fixedgrid +13. Read this doc. Proceed with the 5th item under Development/Profiling + +## Logging + +The "Logs" section will record Claude's work. Please use the following format: + +### (Short summary of the work) + + + +### (Short summary of the work) + + + +... + + +## Logs + +### 2026-06-09 (Analysis of calc_LWx eellipse bottlenecks) + +**Code examined:** `astropath/localization.py:calc_LWx`, the `eellipse` +branch (lines 63-81), plus its two callers in +`astropath/bayesian.py`: `px_Oi_fixedgrid` (line 122, called once per +analysis) and `px_Oi_local` (line 209, called **once per candidate** +inside the galaxy loop). + +**What the eellipse branch does:** +1. `SkyCoord(ra=ra, dec=dec, unit='deg')` — builds a SkyCoord from the + whole grid (lines 69-70). +2. `center.separation(coord)` — Vincenty angular separation (line 72). +3. `center.position_angle(coord)` — position angle E of N (line 73). +4. Rotates into the ellipse frame and evaluates a 2D Gaussian (74-81). + +**Bottleneck identified:** steps 1-3 are the cost. They are pure +astropy and dominate the branch. The arithmetic in steps 1-3 is +trivial; the expense is astropy's per-call machinery — SkyCoord object +construction, `Quantity`/unit wrapping, and `.to('arcsec')` / +`.to('deg')` conversions. I confirmed this with two benchmarks +(grid mimicking `box_hwidth=10"`, `step_size=0.1"`): + +| grid | pts | astropy | numpy | speedup | +|-------------|-------|-----------|-----------|---------| +| 20x20 | 400 | 0.342 ms | 0.018 ms | ~19x | +| 60x60 | 3600 | 0.509 ms | 0.112 ms | ~4.5x | +| 200x200 | 40000 | 3.13 ms | 1.13 ms | ~2.8x | + +The speedup grows as the grid shrinks because astropy's overhead is +largely fixed per call. This matters most in `px_Oi_local`, which +calls `calc_LWx` once per candidate on small per-galaxy grids — the +regime where the win is ~19x. + +**How to replace all astropy calculations:** astropy's `separation` and +`position_angle` are just closed-form spherical formulas +(`astropy.coordinates.angle_utilities`). They can be reproduced exactly +in numpy. Working from the center (ra0, dec0) and grid (ra, dec), all +in radians: + +``` +dlon = ra - ra0 +sdlon, cdlon = sin(dlon), cos(dlon) +sl1, cl1 = sin(dec0), cos(dec0) +sl2, cl2 = sin(dec), cos(dec) +# separation (Vincenty), radians: +sep = arctan2(hypot(cl2*sdlon, cl1*sl2 - sl1*cl2*cdlon), + sl1*sl2 + cl1*cl2*cdlon) +# position angle E of N, radians: +pa = arctan2(sdlon*cl2, sl2*cl1 - cl2*sl1*cdlon) +``` + +I verified these against astropy on the 200x200 grid: max separation +diff ~7e-11 arcsec, max PA diff ~1e-8 deg — i.e. bit-for-bit +equivalent for our purposes. `sep` then goes to arcsec via +`degrees(sep)*3600`, `pa` to degrees via `degrees(pa)` (no need to +wrap to [0,360) since the result is fed straight into `sin`/`cos`). + +The center RA/Dec come from `localiz['center_coord'].ra.deg` / +`.dec.deg` (read once, cheap). The `coord.equinox = +localiz['center_coord'].equinox` line (70) is a no-op for the +math — ICRS separation/PA don't depend on equinox — and can be +dropped in the numpy path. + +**Recommendations (no code written yet):** +1. Replace the SkyCoord/separation/position_angle block in the + `eellipse` branch with the numpy formulas above. Identical results, + ~3-19x faster depending on grid size. +2. Bigger structural win: in `px_Oi_local` the localization mapping is + rebuilt per candidate. `px_Oi_fixedgrid` already computes `L_wx` + once (good). Worth revisiting `px_Oi_local` after step 1. +3. Keep the spherical (not flat-sky) formula so numerical results are + unchanged; only the implementation changes. + +**Question for next prompt:** Should I prioritize (a) just the in-place +numpy swap inside `calc_LWx`'s eellipse branch (lowest risk, drop-in, +identical output), or also (b) vectorize/cache across the candidate +loop in `px_Oi_local`? And is exact equivalence with astropy required, +or is the existing flat-sky approximation already accepted such that I +could simplify further? + +### 2026-06-09 (Implemented numpy calc_LWx + speed-up tests) + +**Code changed:** `astropath/localization.py:calc_LWx`, eellipse branch. +Replaced the astropy block (`SkyCoord` build, `.separation()`, +`.position_angle()`, and `units`-based rotation) with the pure-numpy +Vincenty separation + position-angle formulas worked out in the prior +log entry. The rest of the branch (rotation into the ellipse frame, the +2D-Gaussian evaluation) is unchanged, so output is numerically +identical. The `coord.equinox = ...` line was dropped (no-op for ICRS +separation/PA). Note: the `from astropy import units` import in +localization.py is now unused (a Hint-level lint); left in place since +it is harmless and `units` is a common re-export — can remove if +desired. + +**Tests added:** `astropath/tests/test_speed_up.py`, modeled on +`tests/test_localization.py`. It freezes the original astropy eellipse +code as `_calc_LWx_eellipse_astropy()` (the requested "keep the astropy +code as a test case") and: +- `test_eellipse_matches_astropy` — 200x200 grid, asserts + `np.allclose(rtol=1e-8, atol=1e-12)` against the astropy reference. +- `test_eellipse_matches_astropy_offcenter` — southern, high-PA case + (dec=-50.8, theta=110) to exercise the geometry. +- `test_eellipse_speed_up[200|1000|7200]` — times both implementations, + re-checks correctness, prints the speed-up, and asserts numpy is not + slower. Includes the requested **7200x7200** grid. + +**Measured results** (astro14 env, best-of-3, run with `pytest -s`): + +| grid | pts | astropy | numpy | speed-up | +|-------------|------------|------------|------------|----------| +| 200x200 | 40,000 | 2.95 ms | 2.39 ms | 1.2x | +| 1000x1000 | 1,000,000 | 141.3 ms | 85.0 ms | 1.7x | +| 7200x7200 | 51,840,000 | 11,984.9 ms| 6,092.0 ms | 2.0x | + +For very large grids the win plateaus at ~2x (memory-bandwidth-bound on +the shared trig terms, no longer astropy-overhead-bound). The big-grid +gains are smaller than the small-grid microbenchmark in the previous +entry (~19x at 20x20) precisely because the per-call astropy overhead +is fixed — it dominates only when the grids are small, i.e. the +`px_Oi_local` per-candidate regime (to be revisited later). + +**Verification:** all 5 new tests pass; the existing +`test_path.py`, `test_localization.py`, and `test_bayesian.py` suites +(7 tests) still pass, confirming the eellipse path is unchanged +downstream. + +### 2026-06-09 (Analysis of px_Oi_fixedgrid bottlenecks) + +**Code examined:** `astropath/bayesian.py:px_Oi_fixedgrid` +(lines 67-153), plus the `pw_Oi` it calls (15-64). + +**Astropy usage in the function:** +1. Line 105 — `localiz['center_coord'].equinox = cand_coords[0].equinox` + (one-time; sets an attribute). +2. Lines 119-120 — `localiz['center_coord'].ra.deg`, + `np.cos(localiz['center_coord'].dec).value` to build the grid + (one-time, scalar; cheap). +3. Line 122 — `calc_LWx` (now pure numpy for eellipse; one call). +4. **Lines 126-130 (the per-candidate loop)** — + `for cand_coord in cand_coords` plus, *each iteration*, + `np.cos(cand_coord.dec).value`, `cand_coord.ra.deg`, + `cand_coord.dec.deg`. + +**Bottleneck identified:** the per-candidate loop (item 4). Two costs: +- Iterating a SkyCoord array (`for cand_coord in cand_coords`) builds a + fresh *scalar* SkyCoord object every candidate — expensive astropy + object construction. +- The three attribute accesses per candidate each go through astropy's + `Longitude`/`Latitude`/`Quantity` machinery. + +Together this is ~100 us per candidate of pure astropy overhead that +has nothing to do with the actual math. I benchmarked it (N=50 +candidates, 200x200 grid, best of 20): + +| approach | time/call | +|---------------------------------------|-----------| +| iterate SkyCoord + attr per candidate | 8.75 ms | +| pre-extract arrays once + index | 3.12 ms | +| (pure astropy attr access alone) | 5.06 ms | + +So ~5.6 ms/call (2.8x on the theta-build slice) is removed simply by +pulling the candidate coordinates out of the SkyCoord *once* before the +loop. The saving is fixed per candidate, so it grows with the number of +candidates and dominates when grids are small. + +Note: the genuinely heavy numeric work — building `theta`, `pw_Oi` +(`exp`/`log`), the `L_wx * p_wOi` product and `np.sum` over ngrid^2, +done N_cand times — is already pure numpy. That is O(N_cand * ngrid^2) +and is the floor for large grids; the astropy cleanup does not touch it. + +**How to replace all astropy calculations:** +1. Before the loop, extract candidate coords to plain numpy arrays once: + `cand_ra = cand_coords.ra.deg`, `cand_dec = cand_coords.dec.deg`, + and precompute `cos_cand_dec = np.cos(np.radians(cand_dec))`. Inside + the loop, index with `cand_ra[icand]` etc. — no scalar SkyCoord, no + per-iteration astropy attribute access. +2. Extract the center once with numpy too: `center_ra = ...ra.deg`, + `center_dec = ...dec.deg`, `cos_center_dec = + np.cos(np.radians(center_dec))` (replaces the astropy + `np.cos(...).value` on line 120). +3. Drop the equinox line (105). It is a no-op for the numpy paths + (calc_LWx eellipse ignores equinox; healpix/wcs never used it) and + the offsets here are computed flat-sky, not via spherical frames. + +**On storing ra/dec in radians (the doc's hint):** modest, situational. +- The flat-sky `theta` (lines 129-130) uses *degree differences* scaled + by 3600 to arcsec; in radians it would be `206265 * sqrt(...)`. + Mathematically identical, no speed difference — not worth changing. +- The real redundancy is that `calc_LWx`'s eellipse branch now does + `np.radians(ra)` and `np.radians(dec)` over the *whole* grid on every + call. In `px_Oi_fixedgrid` that is a single call, so it is a one-time + cost — minor here (it matters more for `px_Oi_local`, deferred). If we + ever want to shave it, the clean move is to build the grid in radians + up front and let `calc_LWx` accept radians (or cache the radian grid), + rather than threading radians through the theta loop. + +**Recommendations (no code written yet):** +1. Pre-extract candidate and center coordinates to numpy arrays once; + index by `icand` in the loop. Biggest, safest win; output identical. +2. Remove the equinox-setting line. +3. (Optional, separate change) Vectorize the candidate loop with + broadcasting — compute `theta`/`p_wOi` for all candidates at once as + an (N, ngrid, ngrid) array. Fast for moderate sizes but memory grows + as N_cand * ngrid^2 (e.g. 50 cands x 7200^2 x 8 B ~ 20 GB). Must keep + the per-candidate loop for very large grids, or chunk it; flag the + trade-off rather than vectorize unconditionally. +4. (Optional) `pw_Oi` already masks to `theta < max*phi`; `theta` + itself is still computed over the full grid. Could restrict the + sqrt/exp to the in-support region, but that complicates the code for + limited gain — lower priority than items 1-2. + +**Question for next prompt:** For item 1, confirm `cand_coords` is +always an array-valued SkyCoord (it is built that way in `path.py`) so +`cand_coords.ra.deg` returns an array — any single-candidate call sites +I should guard against? And do you want me to implement just items 1-2 +(safe, identical output), or also pursue the vectorization in item 3 +with a memory guard? + +### 2026-06-09 (Implemented numpy px_Oi_fixedgrid items 1-2 + tests) + +**Scope:** implemented only items 1 and 2 from the recommendations +above (pre-extract coords; drop equinox). No vectorization (item 3) or +`pw_Oi` masking (item 4), per the prompt. + +**Code changed:** `astropath/bayesian.py:px_Oi_fixedgrid`. +- Item 2: removed `localiz['center_coord'].equinox = cand_coords[0] + .equinox` (no-op for the numpy/flat-sky paths). +- Item 1 (center): extract `center_ra`, `center_dec` as plain floats + once and precompute `cos_center_dec = np.cos(np.radians(center_dec))`, + replacing the astropy `np.cos(...).value` in the grid construction. +- Item 1 (candidates): before the loop, pull + `cand_ra = cand_coords.ra.deg`, `cand_dec = cand_coords.dec.deg`, and + `cos_cand_dec = np.cos(np.radians(cand_dec))` as numpy arrays. The + loop is now `for icand in range(cand_ra.size)` and indexes those + arrays — no per-candidate scalar `SkyCoord` construction, no + per-candidate astropy attribute access. Output is numerically + identical (same flat-sky formula, just float vs Quantity extraction). + +**numba consideration:** I kept the inner loop operating purely on +numpy arrays and scalar floats (`cand_ra[icand]`, `cos_cand_dec[icand]`, +`cand_ang_size[icand]`) with no astropy objects or dict access on the +hot path's coordinate math. That is exactly the shape `@njit` wants. +The remaining numba blocker is `pw_Oi`, which branches on the +`theta_prior` dict (string `PDF` key) — to jit the loop later that +PDF selection would need to be hoisted out (resolve the PDF + its +scalar norm once, pass plain floats in), but no restructuring was done +now since the prompt limited scope to items 1-2. + +**Tests added** to `astropath/tests/test_speed_up.py`: +- `_px_Oi_fixedgrid_astropy(...)` — frozen verbatim copy of the original + astropy loop/grid logic (returns the p(x|O_i) array), used as the + regression + speed reference. +- `_make_candidates(...)` — deterministic helper (no RNG) building a + candidate `SkyCoord` + angular sizes around a center. +- `test_px_Oi_fixedgrid_matches_astropy` — 10 candidates, asserts + `np.allclose(rtol=1e-10, atol=1e-15)` vs the astropy reference. +- `test_px_Oi_fixedgrid_speed_up` — 50 candidates, 200x200 grid; times + both, re-checks equality, prints the speed-up, asserts numpy is not + slower. + +**Measured result** (astro14 env, best-of-3, `pytest -s`): + +| case | astropy | numpy | speed-up | +|-------------------------------|----------|----------|----------| +| 50 cand, 200x200 grid | 17.19 ms | 10.23 ms | 1.7x | + +The ~1.7x reflects removing the fixed per-candidate astropy overhead; +the residual time is the genuine numpy compute (theta/pw_Oi/product/sum +over the grid, x50), which is unchanged and would be the next target +for numba or vectorization. + +**Verification:** the 2 new tests pass (plus the 4 existing +test_speed_up tests); `test_path.py`, `test_bayesian.py`, +`test_localization.py` (7 tests) still pass — the fixed-grid posteriors +are unchanged downstream. + +### 2026-06-09 (Profiling module for calc_LWx + px_Oi_fixedgrid) + +**Code added:** `astropath/profiling.py`, modeled on +`calculations/step_size/Profiling.ipynb`. It reuses the notebook's +faux-FRB scenario: FRB at 21h44m25.255s -40d54m00.10s, a circular 5" +error ellipse, two candidate galaxies 1" away, `theta_prior = +dict(max=6, PDF='exp', scale=1)`, `box_hwidth=90"`. + +Structure: +- `default_setup()` — builds the localiz / candidates / prior. +- `_build_grid()` — constructs the fixed ra/dec grid exactly as + `px_Oi_fixedgrid` does (so `calc_LWx` is timed on a realistic grid). +- `_time_call()` — best-of-reps wall timer; reps scale down for big + grids (1 rep > 1e6 px, 2 reps > 1e5, else 3) to keep the sweep quick. +- `run_profiling()` — sweeps `step_size` and returns a pandas table. +- `plot_results()` — log-log figure of time vs grid pixels. +- `main()` / `python -m astropath.profiling` — prints the table and + writes `astropath/profiling_timing.png`. + +**Sweep:** `step_size` in [0.5, 0.25, 0.1, 0.05, 0.025] arcsec which, +with box_hwidth=90", gives side lengths 360 -> 7200 px (the notebook's +max grid). Both `calc_LWx` and `px_Oi_fixedgrid` are timed at each size. + +**Results** (astro14 env, printed to screen): + +| step_size | ngrid | n_pixels | calc_LWx (ms) | px_Oi_fixedgrid (ms) | +|-----------|-------|------------|---------------|----------------------| +| 0.500 | 360 | 129,600 | 8.37 | 10.24 | +| 0.250 | 720 | 518,400 | 40.16 | 52.89 | +| 0.100 | 1800 | 3,240,000 | 286.60 | 393.87 | +| 0.050 | 3600 | 12,960,000 | 1516.86 | 2337.06 | +| 0.025 | 7200 | 51,840,000 | 6230.52 | 9482.16 | + +Both scale linearly with pixel count (slope ~1 on the log-log figure), +as expected for elementwise grid ops. `calc_LWx` is the bulk of +`px_Oi_fixedgrid`'s cost; the gap between the two curves is the +per-candidate theta/pw_Oi/product/sum work (here 2 candidates). Figure +saved to `astropath/profiling_timing.png`. + +**Note:** with the prior astropy implementation the notebook recorded +the localization step at ~8.5 s for the 7200 grid (separation ~2.9 s + +PA ~3 s + coord setup/x,y/L_wx); the numpy `calc_LWx` now does the same +7200 grid in ~6.2 s end-to-end — consistent with the ~2x large-grid +speed-up measured earlier, and the astropy separation/PA cost is gone. + +### 2026-06-09 (Profiling: 50 candidates, plot tweaks) + +**Code changed:** `astropath/profiling.py`, per the three requests. +- `default_setup()` now builds `NCAND=50` candidates (was 2) with a + *range* of locations and sizes: position angles spread evenly over + 0-360 deg, separations `np.linspace(0.5, 10., 50)"`, and angular + sizes `np.linspace(0.2, 3.0, 50)"`. Built deterministically (no RNG) + via `frb_coord.directional_offset_by(pa, sep)` with array arguments. + `ncand` is a keyword arg so the count is easy to vary. +- `plot_results()`: `px_Oi_fixedgrid` is now drawn in **red** + (`color='red'`); `calc_LWx` keeps the default color. +- x-axis now plots `sqrt(n_pixels)` (the grid side length) and is + labeled `sqrt(grid pixels)` instead of raw pixel count. + +**Results** (astro14 env, 50 candidates): + +| step_size | ngrid | n_pixels | calc_LWx (ms) | px_Oi_fixedgrid (ms) | +|-----------|-------|------------|---------------|----------------------| +| 0.500 | 360 | 129,600 | 8.45 | 29.35 | +| 0.250 | 720 | 518,400 | 39.64 | 159.12 | +| 0.100 | 1800 | 3,240,000 | 289.45 | 1810.51 | +| 0.050 | 3600 | 12,960,000 | 1524.50 | 15594.88 | +| 0.025 | 7200 | 51,840,000 | 6130.72 | 65407.29 | + +With 50 candidates the two curves separate clearly (the 2-candidate run +had them nearly on top of each other): `px_Oi_fixedgrid` is now ~3-10x +`calc_LWx` because the per-candidate theta/pw_Oi/product/sum loop runs +50x while `calc_LWx` runs once. This confirms that for many candidates +the per-candidate grid loop — not the localization term — is the +dominant cost, making it the prime target for the next optimization +(numba / vectorization with a memory guard). Figure re-written to +`astropath/profiling_timing.png`. + +### 2026-06-10 (Plan: numba for the px_Oi_fixedgrid main loop) + +**Code examined:** `astropath/bayesian.py` — `px_Oi_fixedgrid` +(lines 67-166) and the `pw_Oi` it calls (15-64). No new code written. + +**What the per-candidate loop does** (lines 139-158), per candidate i: +1. `theta = 3600*sqrt(cos_dec_i^2*(ra-ra_i)^2 + (dec-dec_i)^2)` — a + full-grid temporary. +2. `p_wOi = pw_Oi(theta, phi_i, theta_prior)` — another full-grid + temporary; internally allocates `p` and the boolean mask `ok_w`. +3. `grid_p = L_wx * p_wOi` — a third full-grid temporary. +4. `p_xOi = np.sum(grid_p) * spacing^2` — reduction to a scalar. + +So each candidate allocates ~3-4 arrays the size of the grid (at 7200^2 +that is ~415 MB each) and makes ~5 full-grid passes. With N candidates +that is the cost the profiling showed (px_Oi_fixedgrid ~ N x the inner +work). This is exactly what numba fuses well: one pass, no temporaries. + +**Plan to introduce numba (keeping px_Oi() separate):** + +1. **Factor out a per-candidate kernel `px_Oi(...)`.** Currently no + `px_Oi()` exists (only `pw_Oi` and `px_Oi_fixedgrid`). Create + `px_Oi()` that computes p(x|O_i) for ONE candidate and returns the + scalar. `px_Oi_fixedgrid()` stays the orchestrator: builds the grid, + computes `L_wx` via `calc_LWx`, pre-extracts candidate arrays, and + loops calling `px_Oi()` once per candidate. This is the separation + the prompt asks for and keeps the jitted hot path isolated. + +2. **Make `px_Oi()` a numba `@njit` fused kernel.** Signature roughly: + `px_Oi(ra, dec, L_wx, cand_ra, cand_dec, cos_dec, pdf_code, + theta_max, kparam, norm, spacing) -> float`. It runs a single loop + over grid pixels accumulating `L_wx[p] * p_offset(theta)` and returns + `acc * spacing^2`. No `theta`/`p_wOi`/`grid_p` temporaries — the + dominant memory cost disappears. (Optionally `prange` + reduction for + multi-threading; start single-thread, add `parallel=True` after it + works.) + +3. **Hoist the dict/branching out of the jitted code.** numba nopython + mode does not handle the `theta_prior` dict or string `PDF` + comparisons cleanly. So in `px_Oi_fixedgrid` (plain Python), resolve + the prior ONCE into scalars the kernel can take: + - `pdf_code` int (0=core, 1=uniform, 2=exp), + - `theta_max` cutoff, + - `norm` (the per-candidate normalization), + - `kparam` (the PDF's scale: `phi` for core, `phi*scale` for exp, + unused for uniform). + The kernel then branches on the integer `pdf_code`. **Subtlety to + preserve:** in `pw_Oi` the cutoff `ok_w = theta < max*phi` uses the + ORIGINAL `phi`, while the `exp` decay uses `phi*scale` — these are + different, so the kernel must use `theta_max = max*phi_original` for + the cutoff and `kparam = phi*scale` for the exponent. + +4. **Keep `pw_Oi` as-is.** It is public/tested and used elsewhere + (e.g. `px_Oi_local`). The kernel will duplicate the *elementwise* + PDF formula (one line per PDF) but reuse `pw_Oi`'s exact norm + expressions via a small shared `_offset_norm(pdf, phi, prior)` helper + so the normalization stays single-sourced. Flagging the minor + duplication of the elementwise formula as a maintenance note. + +5. **Fallbacks / optionality.** numba is NOT installed in astro14 + (confirmed: `import numba` -> ModuleNotFoundError). Since this is + "mainly for sandbox analyses", I propose: import numba behind a + try/except; if absent (or a `use_numba=False` kwarg), `px_Oi()` + falls back to the current pure-numpy path so nothing breaks. Add + numba to requirements as optional. + +6. **return_grids / return_debug.** The fused kernel returns only the + scalar, so it cannot produce per-pixel `grid_p`. Plan: use the + jitted kernel only for the common "return p_xOis" case; when + `return_grids`/`return_debug` is set, fall back to the numpy path + (those are debugging/inspection paths, not the hot loop). + +**Validation plan (for the implementation prompt):** reuse +`tests/test_speed_up.py` — assert the numba `px_Oi_fixedgrid` matches +the frozen astropy/numpy reference to roundoff, and time numba vs numpy +across grid sizes (note numba's first call pays JIT-compile time, so +warm up once before timing). + +**Questions for next prompt:** +1. numba is missing from astro14 — should I (a) make it an optional + dependency with a numpy fallback (my recommendation, given "sandbox" + use), or (b) require it and add to requirements/setup? If (a), do you + want a `use_numba` kwarg on `px_Oi_fixedgrid`, or auto-detect? +2. OK to single-source the *norm* in a helper while duplicating the + one-line elementwise PDF inside the kernel, or would you rather I + keep all three PDFs only in `pw_Oi` and have the kernel handle just + `exp` first (the PDF used in profiling/most analyses)? +3. Start single-threaded `@njit`, or go straight to `parallel=True` + with `prange`? (Single-thread first is safer for verifying + correctness; parallel can be a follow-up.) + +### 2026-06-10 (Implemented optional numba kernel for px_Oi_fixedgrid) + +Followed the plan above with the user's clarifications: numba optional, +`use_numba=False` by default, single-source the norm, single-threaded +`@njit`, validate via `test_speed_up.py`. + +**Code changed:** `astropath/bayesian.py`. +- Optional import: `try: from numba import njit / HAS_NUMBA=True` else + `HAS_NUMBA=False` and a no-op `njit` decorator stand-in. numba is not + required to import the module. +- `_resolve_offset_prior(phi, theta_prior)` — new single-source helper + returning `(pdf_code, theta_max, kparam, norm)`. Encodes the PDFs as + ints (`_PDF_CORE/_PDF_UNIFORM/_PDF_EXP`) and preserves the subtlety + that the `exp` cutoff uses the original `phi` (`theta_max=max*phi`) + while the decay length is `phi*scale` (`kparam`). +- `pw_Oi` refactored to call `_resolve_offset_prior` for the norm + + params, then apply the elementwise PDF. Behavior is unchanged (all + existing `test_bayesian` tests pass); the norm is now single-sourced. +- `px_Oi(...)` — new single-threaded `@njit(cache=True)` kernel + computing p(x|O_i) for ONE candidate in a single fused loop over grid + pixels (theta -> PDF -> *L_wx -> sum), with no full-grid temporaries. + Kept separate from both `pw_Oi` and `px_Oi_fixedgrid`. +- `px_Oi_fixedgrid` gained `use_numba=False`. When effective + (`use_numba and HAS_NUMBA and not return_grids/return_debug`) the loop + resolves the prior to scalars and calls the `px_Oi` kernel per + candidate. If `use_numba=True` but numba is absent it `warnings.warn`s + and falls back to numpy; `return_grids`/`return_debug` also force the + numpy path (the fused kernel produces no per-pixel grids). + +**Tests added** to `tests/test_speed_up.py` (skipped if numba absent via +`pytest.mark.skipif(not bayesian.HAS_NUMBA)`): +- `test_px_Oi_fixedgrid_numba_matches_numpy[exp|core|uniform]` — + numba vs numpy agree to `rtol=1e-10` for all three PDFs. +- `test_px_Oi_fixedgrid_numba_fallback_without_numba` — monkeypatches + `HAS_NUMBA=False`, asserts a `UserWarning` is raised and the result + still matches numpy. +- `test_px_Oi_fixedgrid_numba_speed_up` — warms up the JIT, then times + numba vs numpy and prints the speed-up. + +**Measured numba vs numpy** (astro14, 20 candidates, JIT warmed up): + +| grid | numpy | numba | speed-up | +|-------------|-----------|-----------|----------| +| 360x360 | 16.5 ms | 12.3 ms | 1.3x | +| 720x720 | 92.3 ms | 62.4 ms | 1.5x | +| 1800x1800 | 879.7 ms | 446.4 ms | 2.0x | +| 3600x3600 | 7557.0 ms | 2191.3 ms | 3.4x | + +The speed-up grows with grid size, as expected: the numpy path +allocates ~3-4 full-grid temporaries and makes ~5 passes per candidate, +while the fused kernel does one pass with no temporaries — so the win is +largest exactly where memory bandwidth dominates (big grids). For small +grids the gain is modest (and the first call additionally pays one-time +JIT compilation, not shown here since it is warmed up). All 25 tests in +the relevant suites pass. + +**Maintenance note:** the elementwise PDF formula now exists in two +places — `pw_Oi` (numpy) and the `px_Oi` kernel (numba). The +*normalization* and parameter resolution are single-sourced in +`_resolve_offset_prior`, but the per-pixel PDF line itself is +necessarily duplicated for the jitted path; a new PDF must be added to +both (and `_resolve_offset_prior`). + +### 2026-06-10 (Profiling: added numba curve + speed-up report) + +**Context:** the user renamed the kernel `px_Oi` -> `px_Oi_numba` in +`bayesian.py` (call site updated to match). This entry updates +`astropath/profiling.py` to exercise the `use_numba=True` path. + +**Code changed:** `astropath/profiling.py`. +- `run_profiling()` now warms up the numba JIT once (small grid) before + timing, then for each grid size also times + `px_Oi_fixedgrid(..., use_numba=True)`. Adds a `px_Oi_numba_s` + column (NaN if `bayesian.HAS_NUMBA` is False). +- `plot_results()` adds a third curve (green triangles) for the numba + path, drawn only when numba timings exist; the numpy curve is now + labeled "px_Oi_fixedgrid (numpy)". Title -> "numpy vs numba". +- `main()` table now prints numpy vs numba times side by side plus a + `numba_speedup` column. + +**Results** (astro14, 50 candidates, box_hwidth=90"): + +| step_size | ngrid | calc_LWx (ms) | numpy (ms) | numba (ms) | speed-up | +|-----------|-------|---------------|------------|------------|----------| +| 0.500 | 360 | 9.68 | 30.21 | 18.46 | 1.64x | +| 0.250 | 720 | 42.58 | 169.26 | 81.11 | 2.09x | +| 0.100 | 1800 | 296.46 | 1767.59 | 590.88 | 2.99x | +| 0.050 | 3600 | 1507.34 | 15659.78 | 2874.86 | 5.45x | +| 0.025 | 7200 | 6092.52 | 65256.18 | 11548.08 | 5.65x | + +**Speed-up report:** numba accelerates the fixed-grid p(x|O_i) by +~1.6x on small grids up to ~5.7x at 7200x7200 with 50 candidates — +larger than the 20-candidate run logged earlier (max 3.4x) because more +candidates mean more passes over the grid, so eliminating the per-pixel +temporaries pays off more. On the figure the numba curve (green) sits +between `calc_LWx` (blue) and the numpy `px_Oi_fixedgrid` (red): at the +largest grid the per-candidate work is no longer dominating — numba +brings it down toward the cost of the single `calc_LWx` localization +pass. Figure re-written to `astropath/profiling_timing.png`. + +### 2026-06-10 (Documentation: numpy/numba speed-ups + profiling) + +**Docs added/updated** under `docs/`. +- New page `docs/performance.rst` with sections: (1) the transparent + numpy acceleration of `calc_LWx` (eellipse) and `px_Oi_fixedgrid`; + (2) the optional numba option — how to enable it + (`px_Oi_fixedgrid(..., use_numba=True)`) and the key caveats; (3) the + `profiling` module (CLI `python -m astropath.profiling` + import use), + with an `automodule` API reference. +- Emphasized per the prompt: numba is **optional** (need not be + installed), `use_numba` defaults to **False**, and the code **falls + back to numpy** (with a warning) if numba is absent or the flag is not + set; the numba option is available **only for `px_Oi_fixedgrid`** + (not `px_Oi_local`/others, and bypassed for + `return_grids`/`return_debug`); and it is **primarily recommended for + sandbox analyses**. +- Added an honest `.. note::` that `use_numba` is exposed on + `bayesian.px_Oi_fixedgrid` directly and is *not* currently forwarded + by `path.PATH.calc_posteriors` (verified in `path.py`) — call the + bayesian function directly to use it. +- Linked the new page from `docs/index.rst` (new "Performance" + toctree section). Added cross-reference `.. note::` pointers in + `docs/frb_example.rst` (posterior step) and `docs/localization.rst` + (calc_LWx eellipse) to `:doc:\`performance\``. + +**Validation:** sphinx/docutils are not installed in astro14, so I +could not run `make html` here. Instead I checked that all RST section +underlines are >= their title length (no would-be build warnings) and +that every `index.rst` toctree entry resolves to an existing +`.rst`/`.ipynb` file. Both checks pass. A full `make html` should be +run in the docs environment to confirm rendering. + +### 2026-06-10 (numba: match the optional correction factor) + +**Context:** the user added an optional `correction` kwarg to the numpy +`px_Oi_fixedgrid` (`'p_wO'`, `'L_wx'`, or `None`). For a candidate the +numpy path does `grid_p = L_wx * p_wOi`, then divides the grid by a +scalar — `sum(p_wOi)/spacing^2` for `'p_wO'` (candidate-dependent) or +`sum(L_wx)/spacing^2` for `'L_wx'` (candidate-independent) — before +summing. This entry makes the numba path apply the identical +correction. + +**Code changed:** `astropath/bayesian.py`. +- `px_Oi_numba` now also accumulates `pw_sum = sum(p(w|O_i))` over the + grid and returns `(p_xOi_uncorrected, pw_sum)`. Since p(w|O_i)=0 + outside the support (`theta >= theta_max`), accumulating only inside + the cutoff gives the full-grid sum, matching numpy's `np.sum(p_wOi)`. +- In the `use_numba` branch of `px_Oi_fixedgrid`, after the kernel call + I apply the SAME correction expressions as the numpy branch. Key + identity: dividing the grid by a scalar then summing equals dividing + the scalar sum, so correcting the returned scalar p(x|O_i) is exact: + - `'p_wO'`: `p_val /= pw_sum / spacing^2` + - `'L_wx'`: `p_val /= np.sum(L_wx) / spacing^2` + No correction logic was duplicated inside the jitted kernel; only the + extra `pw_sum` reduction is. (`return_grids`/`return_debug` still force + the numpy path, so the grid-level correction there is unaffected.) + +**Tests added** to `tests/test_speed_up.py`: +- `test_px_Oi_fixedgrid_numba_matches_numpy_correction[p_wO|L_wx] + [exp|core|uniform]` — 6 cases asserting numba == numpy to + `rtol=1e-10` with each correction. All pass (11 numba tests total). + +**Note — unrelated pre-existing test failure:** `test_bayesian.py:: +test_PU` fails in the current working tree, but NOT from this change. +It is caused by a separate uncommitted user edit to `px_U` (signature +`box_hwidth`->`radius`, formula `1/(2*box_hwidth)^2` -> +`1/(pi*radius^2)`); `px_U(30)` changed from `1/3600` to `1/(pi*900)`, +which breaks `test_PU`'s hard-coded expected `p_x`/`P_Ux`. Verified by +running `test_PU` on the committed baseline (passes) vs the working +tree (fails on the `p_x` assertion). Left untouched — it is outside the +scope of this prompt and reflects an intentional user change; the +`test_PU` expectations (or `px_U` call sites) likely need updating +separately. + +### 2026-06-10 (Profiling: time JIT warm-up + default correction='p_wO') + +**Code changed:** `astropath/profiling.py`. +- **JIT warm-up now timed.** Removed the separate, untimed numba + warm-up call. The numba path is now timed with `reps=1` (added a + `reps` override to `_time_call`), so the *first* (smallest-grid) numba + call pays the JIT compilation and that cost is reflected in its + reported time — a realistic one-off sandbox cost. +- **Default `correction='p_wO'`.** All `px_Oi_fixedgrid` timings in the + sweep (both numpy and numba) now pass `correction='p_wO'` (set once at + the top of `run_profiling`). The numpy timing call was wrapped in a + lambda to thread the kwarg through. + +**Results** (astro14, 50 candidates, correction='p_wO'): + +| step_size | ngrid | calc_LWx (ms) | numpy (ms) | numba (ms) | speed-up | +|-----------|-------|---------------|------------|------------|----------| +| 0.500 | 360 | 8.61 | 30.48 | 223.20 | 0.14x | +| 0.250 | 720 | 41.62 | 171.61 | 81.18 | 2.11x | +| 0.100 | 1800 | 284.20 | 1875.81 | 605.40 | 3.10x | +| 0.050 | 3600 | 1534.47 | 15954.46 | 2938.61 | 5.43x | +| 0.025 | 7200 | 6452.22 | 68480.97 | 12018.50 | 5.70x | + +The first numba point is now **slower** than numpy (0.14x, 223 ms) — +that row absorbs the one-time JIT compilation (~0.2 s). From the second +grid on, the kernel is compiled and the true 2.1x->5.7x speed-ups +return. On the figure this shows as the leftmost green point sitting +*above* the red numpy point, then dropping below — i.e. numba only pays +off once the per-call work exceeds the compile overhead. Figure +re-written to `astropath/profiling_timing.png`. \ No newline at end of file diff --git a/prompts/speed_up_local.md b/prompts/speed_up_local.md new file mode 100644 index 0000000..3978052 --- /dev/null +++ b/prompts/speed_up_local.md @@ -0,0 +1,1030 @@ +# Speeding up the PATH calculations + +## Goals + +This document is a collection of ideas and prompts for speeding up the PATH calculations for the bayesian.px_Oi_local method. + +## Coding + +Here are guidelines for coding: + +- Examine the work described in the speed_up_fixed.md document. +- Use Python where possible +- Add inline comments to explain the effort +- Reuse existing code when possible, especially in bayesian.py and localization.py +- Place import statements at the top of the file. +- Include a description of inputs/outputs in the doc string of all methods +- Use lines of code that are less than 80 characters wide + +## Running + +If you need to run python, use the "astro14" environment. + +## Testing + +As we will be making a number of significant changes to the code, we will need to generate a set of tests to verify the code as we develop the new method. + +1. Generate a new module named tests_local.py in astropath/tests. In it place a series of tests that compare the current px_Oi_local method against the px_Oi_fixedgrid method run with a fine grid. For this: + +- Draw on examples in the Notebooks in the astropath/calculations/step_size directory. +- Use a fine enough step size for the px_Oi_fixedgrid method to be considered accurate +- Generate examples for at least these 3 cases: + * A large galaxy (10") with a small localization (1") + * A large galaxy (10") with a large localization (10") + * A small galaxy (1") with a small localization (1") + * A small galaxy (1") with a large localization (10") + * A small galaxy (0.5") with an ellipse localization (a=10", b=0.2") +- Log your work in the "Logs" section below. + +2. The test_run.py tests are failing in CI on GitHub Actions. But they are working fine locally. Can you investigate? Log your work and findings in the Logs section below. + +3. Proceed with the change to the test_run.py tests that you proposed (pmode="local"). Log your work and findings in the Logs section below. + +4. One of the tests in test_path.py is failing. Please: + - Examine the code + - Find a fix + - Implement it + - Log your work in the "Logs" section below. + +## Development + +We wish to speed up the calculations in bayesian.py:px_Oi_local. +We will begin by removing all astropy calculations and replacing them with numpy calculations. We will then use numba to speed up the code. + +1. Examine the code in bayesian.py:px_Oi_local. Please: + +- Examine the code +- Identify the bottlenecks +- Figure out how to replace all astropy calculations +- When we test, we will use the tests_local.py module to verify the code. It will not be necessary to preserve a copy of the original algorithm +- Log your work in the "Logs" section below. +- Make recommendations +- Do not generate any new code yet +- If you have any questions, ask them in the Logs and I will clarify at my next prompt + +2. Write new code to replace the astropy calculations with numpy calculations. Please: + +- Here are answers to your questions: + * Only consider the ellipse localization type for now. + * Flat sky is acceptable +- Remember that we intend to use numba to speed up the code. Consider that in your programming +- Verify using the tests_local.py module that the code is working as expected. +- Add new code to profiling.py to profile this method +- Log your work in the "Logs" section below. + +3. I have reduced the default step size to 0.05, relative to the galaxy angular size. This will not be small enough when the localizatoin error is very small. In that case, we need to calculate a correction similar to what is done in the fixed method. The subtlety is that we need to correct it centered on the localization and not at the galaxy. Please update the code to implement this. It will mean: + +- Checking to see if b is less than the galaxy angular size. If not, we can ignore the correction. +- Calculate a new grid roughly centered on the localization but shifted from the galaxy grid. That is, the localization grid is like an extension of the galaxy grid. +- I have put a hook in the code to allow for a correction. If b < phi_cand, you should calculate the correction and apply it to the grid. +- Log your work in the "Logs" section below. + +4. While your _local_lwx_correction helper works well, it is not exactly what I had in mind. Let us develop an alternative approach which won't be as accurate but should be much faster. Here is what the helper function should do: + +- Calculate L_wx approximately centered on the localization. +- The grid should be large enough to cover most of the ellipse (4 sigma along the major axis) +- The grid is spaced exactly the same as the galaxy grid (step_size_phi) +- The grid should be aligned to the galaxy grid, i.e. only shifted by an integer number of cells in x and y +- For phi_cand much greater than b, the total L_wx will be significantly less than 1 and we will correct our calculation by this factor +- We will name this helper _Lwx_correction() +- Be careful not to generate any arrays larger than approximately 5000x5000 cells. + +The main point is that we will under-resolve the localization in our calculation. But we can calculate the correction factor and apply it to the grid. I have found that this is accurate to ~1% for the cases I have tested. + +Consider the above and Log a plan in the "Logs" section below. Do not generate any new code yet. + +5. What you describe in the logs looks correct. Please: + +- proeed to generate the code. +- Do use a square window for the correction. +- Log your work in the "Logs" section below. + + +## Profiling + +1. Please make the following modification to profiling.py: + +- Add an additional test for the local method which uses an ellipse localization with a relatively large axis ratio. Large enough to require an approximately 1000x1000 grid for the L_wx correction. +- Include this curve in the figure for the local method. + +2. The purple curve in the local figure says circular but no correction. Please: + +- check whether there is a correction. +- update the figure as needed +- Log your work in the "Logs" section below. + +3. Add one more test to profiling.py for the local method: + +- Use a very small localization in both dimenstions (a=0.1", b=0.1") +- Include galaxy sizes from 0.1" to 20" +- If necessary, have the test_local.py module include an accuracy test for a small localization too +- Log your work in the "Logs" section below. + +## Docs + + +1. Examine the docs in the astropath/docs directory. We need to update the documentation to reflect the new code. Please: + +- Update the documentation to reflect the new code for the local method +- Note that it does not require numba (for now) +- Comment on the profiling.py module too +- Log your work in the "Logs" section below. + +2. Please add the results on accuracy and profiling to the docs/performance.rst file. And: + +- Include the 2 profiling figures (re-generate them first) +- Include tables summarizing the accuracy and profiling results + + + +## Prompts + +1. Read this doc. Proceed with the 1st item under Testing. +2. Read this doc. Proceed with the 1st item under Development. +3. Read this doc. Proceed with the 2nd item under Development. +4. Read this doc. Proceed with the 3rd item under Development. +5. Read this doc. Proceed with the 4th item under Development. +6. Read this doc. Proceed with the 5th item under Development. +7. Read this doc. Proceed with the 1st item under Docs +8. Read this doc. Proceed with the 1st item under Profiling +9. Read this doc. Proceed with the 2nd item under Profiling +10. Read this doc. Proceed with the 3rd item under Profiling +11. Read this doc. Proceed with the 2nd item under Docs +12. Read this doc. Proceed with the 2nd item under Testing. +13. Read this doc. Proceed with the 3rd item under Testing. +14. Read this doc. Proceed with the 4th item under Testing. + +## Logging + +The "Logs" section will record Claude's work. Please use the following format: + +### (Short summary of the work) + + + +### (Short summary of the work) + + + +... + + +## Logs + +### 2026-06-10 (Generated tests_local.py: px_Oi_local vs fine fixed grid) + +**What I built:** A new test module +`astropath/tests/tests_local.py`, modeled after `test_speed_up.py` and +the `calculations/step_size/test_accuracy.py` notebook helpers. It +verifies that `bayesian.px_Oi_local` reproduces +`bayesian.px_Oi_fixedgrid` run on a fine, large-enough grid (taken as +the accurate reference). + +**Key insight (why this is a valid comparison):** both methods evaluate +the same integral `p(x|O_i) = ∫ L(w-x) p(w|O_i) dw`, just discretized on +different grids. `px_Oi_local` centers a grid on the *galaxy* sized to +the offset-prior support (`phi*max`); `px_Oi_fixedgrid` centers on the +*transient*. The integrand is non-zero only within `phi*max` of the +galaxy (the offset prior has a hard cutoff there), so a fixed-grid box +of `offset + phi*max + 3"` fully contains it. I confirmed the reference +value is unchanged when the box is enlarged further, so box size is not +limiting. + +**Convergence measured:** `px_Oi_local`'s relative error vs the fine +fixed grid is first-order in the (relative) step size, ≈ `0.167 * +step_size`: + +| step_size | reldiff | +|-----------|---------| +| 0.100 | -1.67% | +| 0.050 | -0.83% | +| 0.020 | -0.33% | +| 0.010 | -0.17% | +| 0.005 | -0.08% | + +So the two methods provably converge to the same number. + +**Cases covered** (all 5 from the prompt — the prompt says "at least +3" but lists 5): +- large galaxy 10" / small loc 1" +- large galaxy 10" / large loc 10" +- small galaxy 1" / small loc 1" +- small galaxy 1" / large loc 10" +- small galaxy 0.5" / ellipse loc a=10", b=0.2" + +**Tests written:** +1. `test_local_matches_fine_fixedgrid` (parametrized over the 5 cases) — + runs the local method at `step_size=0.02` and asserts agreement + with the fine fixed grid to `rtol=1e-2`. Observed reldiff is a + remarkably consistent ≈ -3.34e-3 across every regime. +2. `test_local_multi_candidate_matches_fixedgrid` — drives all regimes + through the candidate loop (a guard for future vectorization/numba), + each checked against its own reference. +3. `test_local_convergence_to_fixedgrid` — confirms the error decreases + monotonically and roughly halves when the step halves (first-order). + +**Result:** `pytest astropath/tests/tests_local.py -s` → 7 passed in +~10s. The reference grids stay tractable (largest is 3840² for the +10"-galaxy / 1"-loc case, ~3s; the b=0.2" ellipse needs a 0.007" step, +~1s). These now serve as the regression baseline for the upcoming +numpy/numba rewrite of `px_Oi_local`. + +**Question for next prompt:** the `Development` section says to remove +astropy from `px_Oi_local`. Should I keep the existing astropy-based +`px_Oi_local` frozen as a reference (as was done for `calc_LWx` / +`px_Oi_fixedgrid` in `test_speed_up.py`), or is the fine-fixed-grid +comparison in `tests_local.py` sufficient as the regression anchor? + +> Answer (recorded by user in the next prompt): no need to preserve a +> copy of the original algorithm; `tests_local.py` is the regression +> anchor. + +### 2026-06-10 (Analysis of px_Oi_local: bottlenecks + astropy removal) + +**Code examined:** `bayesian.px_Oi_local` (lines 347-411). It loops +over candidates; for each it (1) builds a square grid centered on the +galaxy, sized `box_hwidth = phi*max` with spacing +`step_size_phi = phi*step_size`, (2) computes `theta = sqrt(x^2+y^2)` +and `p_wOi = pw_Oi(theta, phi, prior)`, (3) builds flat-sky `ra/dec` +around the galaxy, (4) calls `localization.calc_LWx(ra, dec, localiz)`, +(5) accumulates `sum(L_wx * p_wOi) * step_size_phi^2`. + +**Astropy inventory (everything in the loop body):** +- `for icand, cand_coord in enumerate(cand_coords)` -- iterating a + SkyCoord array; each item is a scalar SkyCoord (slicing overhead). +- `cand_coord.ra.deg` (line 396). +- `np.cos(cand_coord.dec).value` (line 397) -- Angle trig + `.value`. +- `cand_coord.dec.deg` (line 398). +- Inside `calc_LWx`: `localiz['center_coord'].ra.deg` / `.dec.deg` + (read once per call -> N times). The eellipse *math* in calc_LWx is + already pure numpy (done in the earlier speed_up_fixed.md work). +- No `units` usage in px_Oi_local itself (the module-level + `from astropy import units` is only used by the deprecated + `px_Oi_orig`). + +**Profile (200 candidates, step_size=0.1, mixed sizes, 3 reps, +cProfile, cumulative):** + +| component | share of runtime | +|-----------|------------------| +| `calc_LWx` (numpy Vincenty sep + PA + Gaussian) | ~58% | +| astropy coordinate access/iteration (SkyCoord, Angle, represent_as) | ~25-30% | +| `pw_Oi` | ~5% | +| `np.meshgrid` + grid build | ~3% | + +Wall time ~1.0 ms/candidate at step_size=0.1. + +**Bottleneck #1 -- `calc_LWx` doing spherical trig on a flat-sky grid.** +px_Oi_local already *builds* `ra/dec` with a flat-sky tangent-plane +approximation, then `calc_LWx` (eellipse) runs the FULL Vincenty +angular separation + position angle (`arctan2`, `hypot`, several +`sin/cos`) to recover offsets it effectively already knows. Micro-bench +on a 120x120 grid: `calc_LWx` (Vincenty) = 601 us/call vs a direct +flat-sky Gaussian = 100 us/call -- **~6x** -- agreeing to a max +fractional difference of 1.1e-5 (negligible at arcsec grid scale). + +**Bottleneck #2 -- per-candidate astropy coordinate access.** Same +issue fixed earlier in `px_Oi_fixedgrid`: iterating a SkyCoord and +reading `.ra/.dec` per candidate is pure overhead (~25-30% here). + +**Key structural finding -- the grid and `p_wOi` are phi-independent.** +Because `box_hwidth = phi*max` and `step_size_phi = phi*step_size`, + + ngrid = round(2*box_hwidth/step_size_phi) = round(2*max/step_size) + +so `ngrid` is the SAME for every candidate (e.g. 120 for max=6, +step_size=0.1; verified). Writing the grid as `phi*max * U` for a +fixed normalized meshgrid `U`, one finds `theta = phi*max*R` and: +- core: `p_wOi = (1/(max*R+1)) / norm(phi)` +- exp: `p_wOi = exp(-max*R/scale) / norm(phi)` +- uniform: `p_wOi = 1 / norm(phi)` + +i.e. the *shape* of `p_wOi` (and the cutoff mask `R<1`) does NOT depend +on phi -- only the scalar `norm(phi)` and the `step_size_phi^2 = +(phi*step_size)^2` factor do. So `meshgrid`, `theta`, `R`, and the +exp/core grid can be computed ONCE and reused for all candidates. + +**Important constraint -- px_Oi_local must stay generic over +localization type.** Its docstring ("best for large localization +areas which cover a large area of the sky") points at healpix maps +(CHIME baseband), and `calc_LWx` also serves `wcs`. For healpix/wcs, +`L_wx` is a pixel lookup that genuinely needs `ra/dec`, so we cannot +drop `calc_LWx` wholesale -- the flat-sky shortcut (Bottleneck #1) +applies only to the `eellipse` branch. + +**Plan to replace astropy (for the next coding step -- not done yet):** +1. Pre-extract `cand_ra = cand_coords.ra.deg`, + `cand_dec = cand_coords.dec.deg`, + `cos_cand_dec = np.cos(np.radians(cand_dec))` ONCE before the loop + (mirrors `px_Oi_fixedgrid` lines 269-271). Index these in the loop + instead of touching the SkyCoord. This removes ALL astropy from the + loop body. +2. Pre-extract `center_ra/center_dec` from `localiz['center_coord']` + once, so the per-call astropy read inside `calc_LWx` is avoided for + the local method. (Either compute a flat-sky `L_wx` inline for the + eellipse type, or pass scalars; see recommendations.) +3. After (1)-(2) the only astropy left is constructing the inputs; + px_Oi_local's own computation becomes pure numpy. + +**Recommendations (ordered by payoff; later items target the numba +step the doc mentions, NOT this one):** +- **R1 (biggest, eellipse):** add a flat-sky `L_wx` path for the + eellipse type that reuses the rotation/Gaussian already in + `calc_LWx` but skips Vincenty -- ~6x on the dominant cost. Keep + calling `calc_LWx` for healpix/wcs. Consider factoring the eellipse + Gaussian into a small numpy helper in `localization.py` so both + `calc_LWx` and the local fast path share one definition. +- **R2:** precompute the phi-independent normalized grid + `p_wOi` + shape + cutoff mask once; per candidate only rescale by `norm(phi)` + and multiply the sum by `(phi*step_size)^2`. Removes meshgrid/exp + from the per-candidate loop entirely. +- **R3:** pre-extract candidate/center coordinates (the astropy-removal + in the plan above). +- **R4 (numba step):** with R1-R3 the per-candidate kernel reduces to + "offset the fixed grid by the galaxy's center offset, evaluate the + eellipse Gaussian, multiply by the cached `p_wOi` shape, sum" -- a + tight numeric loop well suited to an `@njit` kernel analogous to + `px_Oi_numba`, computing the eellipse `L_wx` inline. + +**Questions for the next prompt:** +1. Should the optimization target ONLY the `eellipse` localization + type (with healpix/wcs falling back to the current `calc_LWx` + path), or do you also want a fast path for healpix? (My plan above + keeps healpix/wcs on `calc_LWx`.) +2. The flat-sky `L_wx` for eellipse differs from the current Vincenty + result by ~1e-5 fractionally. Confirm that adopting the flat-sky + approximation here is acceptable (it is already used to build the + grid, and `px_Oi_fixedgrid` makes the same approximation). + +### 2026-06-10 (Rewrote px_Oi_local in numpy; ~6.5x faster) + +**Done** (Development item 2). User answers applied: only the +`eellipse` type gets the fast path; flat-sky is acceptable. + +**Changes to `bayesian.px_Oi_local`:** +- **Astropy removed from the loop (R3):** `cand_coords.ra.deg / + .dec.deg` and `cos(dec)` are pre-extracted to numpy arrays ONCE + before the loop; the body indexes those arrays instead of iterating + the SkyCoord. For the eellipse path the localization center is also + pulled out once. No astropy remains in the per-candidate loop. +- **Normalized grid built ONCE (R2, partial):** since `ngrid = + 2*max/step_size` is phi-independent, the loop now reuses a single + normalized meshgrid (U, V, R) rescaled by `phi*max` per candidate + instead of rebuilding `np.meshgrid` each time. (I deliberately did + NOT do the full analytic phi-cancellation of `norm(phi)` -- it would + obscure the algorithm and is unnecessary for the numba step, which + recomputes the PDF per pixel anyway. `pw_Oi` is still reused as-is.) +- **Flat-sky eellipse L_wx (R1, the big win):** for `eellipse`, L(w-x) + is now evaluated directly in the tangent plane -- galaxy-center + offset (E0, N0) plus the grid offsets, rotated into the ellipse frame + (same `dtheta = 90-PA` convention as `calc_LWx`), then the 2D + Gaussian. This skips astropy's Vincenty separation / position angle. +- **Generic fallback preserved:** non-eellipse types (healpix/wcs) + still build flat-sky `ra/dec` and call `localization.calc_LWx`, so + production GW/healpix runs are unaffected. (Caught by the existing + `test_path.py::test_gw`, which has no `center_coord`; the center + extraction is now guarded inside the eellipse branch.) +- **numba-readiness:** the eellipse per-candidate body is now a tight + numeric block (scalars + the fixed normalized grid -> rotation, + Gaussian, weighted sum) that maps cleanly onto a future `@njit` + kernel analogous to `px_Oi_numba`. + +**Verification:** `pytest astropath/tests/tests_local.py -s` -> 8 +passed. The reldiff vs the fine fixed grid is unchanged from the old +Vincenty version (e.g. -3.345e-3 vs -3.348e-3 for the large-galaxy/ +small-loc case) -- i.e. the flat-sky approximation contributes <1e-5, +far below the discretization error and the 1% tolerance. Full suite +(`test_bayesian`, `test_path`, `test_speed_up`, `tests_local`) passes. + +**Speed-up:** in the 200-candidate / step_size=0.1 / eellipse scenario, +0.154 ms/candidate vs ~1.000 ms/candidate before -> **~6.5x** (Vincenty +removal ~6x + per-candidate astropy removal). + +**Profiling added** (`astropath/profiling.py`): new +`run_profiling_local()` sweeps `step_size` (per-candidate grid = +2*max/step_size) for the 50-candidate eellipse scenario, plus +`plot_local_results()` (purple curve, x-axis = sqrt(per-candidate +pixels), 10 s reference line) writing `profiling_local_timing.png`. +`main()` now runs and reports both the fixed-grid and local sweeps. +Sample (50 candidates): + +| step_size | per-cand grid | total ms | ms/cand | +|-----------|---------------|----------|---------| +| 0.500 | 24x24 | 0.9 | 0.018 | +| 0.250 | 48x48 | 1.8 | 0.035 | +| 0.100 | 120x120 | 7.8 | 0.155 | +| 0.050 | 240x240 | 32.8 | 0.655 | +| 0.025 | 480x480 | 182.9 | 3.659 | + +### 2026-06-11 (Small-localization correction, centered on the loc) + +**Done** (Development item 3). The default step is now 0.05 (relative +to phi). That is fine when the localization is comparable to / larger +than the galaxy, but when the minor axis `b < phi` the galaxy-centered +grid (spacing `phi*step`) under-resolves the sharp localization and the +raw sum carries the full O(step) bias (~-0.8% at step 0.05, ~-1.7% at +0.1). I filled the existing `if b < phi_cand:` hook with a correction. + +**What the correction does** (new helper +`bayesian._local_lwx_correction`): +- Builds a SEPARATE grid CENTERED ON THE LOCALIZATION (the transient), + not the galaxy -- the galaxy grid shifted/extended onto the + localization, in the same flat-sky tangent plane. +- The grid is tied to the ELLIPSE, not to `step_size`: half-width + `6a` (covers the major axis so `sum(L)` captures the full, + unit-normalized L) and spacing `b/4` (resolves the minor axis). It is + therefore INDEPENDENT of `step_size`, so coarsening the galaxy step + no longer degrades these cases. `ngrid` is capped at 4000 for extreme + axis ratios. +- Returns `sum(L*p)/sum(L)` -- the L-weighted average of p(w|O_i). The + grid spacing cancels in the ratio and L integrates to 1, so this is + the localization-normalized p(x|O_i), exactly the quantity + `px_Oi_fixedgrid` produces with `correction='L_wx'`. This is "similar + to the fixed method", but centered on the localization as required. +- Only the `eellipse` path uses it (per item 2's scope). For `b >= + phi` nothing changes; the generic healpix/wcs path is untouched. + +**Why a separate, loc-centered grid (the subtlety):** the ratio's +denominator `sum(L)` must capture the FULL localization (so it equals +its analytic norm of 1); a galaxy-centered grid of half-width `phi*max` +fails this when `a > phi*max` (e.g. the a=10",b=0.2" ellipse), giving +`sum(L)` over only a sliver and a ratio ~4x too large. Centering on the +localization with half-width `6a` fixes it. + +**Empirical design** (vs the fine fixed-grid reference, at step 0.05): +| case (b 11 +passed. Added `test_local_correction_coarse_step` (parametrized over +the two `b> b`) the correction grid is `~6a x 6a` at spacing `b/4`, i.e. +`~24 a/b` pixels per side (2400 for the test ellipse; the 4000 cap can +bite for, say, a=60",b=0.2"). An anisotropic grid aligned to the +ellipse axes (fine along the minor, coarse along the major) would cut +this by ~100x; I kept the uniform grid for fidelity to "an extension of +the galaxy grid" and simplicity. Flag if you want the anisotropic +version. + +### 2026-06-11 (PLAN: faster aligned _Lwx_correction; no code yet) + +**Task** (Development item 4): replace the accurate-but-slow +`_local_lwx_correction` with a faster, ~1%-accurate `_Lwx_correction()` +that DELIBERATELY under-resolves the localization on the (coarse) galaxy +grid and divides the raw result by a correction FACTOR. The hook is +already stubbed by you: +``` +if b < phi_cand: + L_wx_correction = _Lwx_correction(arguments) +else: + L_wx_correction = 1.0 +... +grid_p = L_wx * p_wOi / L_wx_correction # scalar divide +p_xOis.append(np.sum(grid_p) * step_size_phi**2) +``` +So `_Lwx_correction()` must return a SCALAR factor; `p(x|O_i)` becomes +`[sum(L*p)*dA] / factor`. + +**What the factor is.** `factor = sum_over(loc grid) L_wx * dA`, i.e. +the DISCRETE integral of L ("total L_wx") evaluated on a coarse grid +centered on the localization. When `phi >> b` the galaxy-grid spacing +`step_size_phi` under-samples the sharp ellipse, so this discrete +integral comes out `< 1` (your observation). Dividing the raw +`sum(L*p)*dA` by it renormalizes L back to 1. + +**Why this works to ~1% even though L is under-resolved -- the key +idea is GRID ALIGNMENT.** The raw numerator `sum_gal L*p*dA` samples L +on the galaxy lattice at some fixed sub-cell phase relative to the +ellipse. If the correction grid is the SAME lattice (same spacing, +shifted by an integer number of cells), it samples L at the SAME +sub-cell phase. Under-resolution then multiplies BOTH the numerator's +L-weighting and the denominator `sum_loc L*dA` by the same (roughly +uniform) aliasing factor, so it cancels in the ratio: + + [sum_gal L*p*dA] / [sum_loc L*dA] + ~= integral(L*p) / integral(L) = integral(L*p) = p(x|O_i) + +(the last step uses integral(L)=1). The residual ~1% comes from the +aliasing factor not being perfectly uniform, the 4-sigma truncation, +and p varying across the product region. Alignment is ESSENTIAL: an +unaligned (differently-phased) correction grid would not cancel and the +error would be large and noisy. This is the crucial difference from +`_local_lwx_correction`, which instead RESOLVED L on a fine (b/4) grid +-- accurate (~1e-5) but slow. + +**Planned `_Lwx_correction()` -- spec.** +- Purpose: return the scalar `sum(L_wx)*dA` over a coarse, + galaxy-grid-aligned grid centered on the localization, so the caller + can divide the (under-resolved) raw p(x|O_i) by it. +- Inputs (all plain floats/arrays, numba-friendly): + * `E0, N0` -- flat-sky offsets of the galaxy from the localization + center (arcsec); already computed in the loop. + * `a, b, cos_dth, sin_dth` -- ellipse semi-axes and the shared + rotation into the ellipse frame. + * the galaxy-grid lattice description so the correction grid can be + built ON the same lattice: pass `box_hwidth` and the shared + normalized axis `u` (=`np.linspace(-1,1,ngrid)`), from which + `h = box_hwidth*(u[1]-u[0])` is the EXACT galaxy-grid spacing + (~`step_size_phi`). (Using the exact `h`, not the nominal + `step_size_phi`, keeps the two grids truly aligned.) + * `step_size_phi` -- only for `dA = step_size_phi**2` (kept identical + to the caller's `dA` so the scalar divide is consistent; any common + dA cancels in the ratio anyway). +- Grid construction (the three constraints you listed): + 1. SAME spacing as the galaxy grid: spacing `= h`. + 2. ALIGNED / integer-cell shift: snap the localization center onto the + galaxy lattice -> `iE = round(E0/h)`, `iN = round(N0/h)`; the 1D + correction coordinates (offsets from the galaxy) are + `(iE + arange(-m, m+1)) * h` and likewise for N, where + `m = ceil(4*a / h)`. These points lie exactly on the galaxy + lattice, just translated by `(iE, iN)` cells. + 3. COVER 4 sigma of the major axis: half-width `4*a` -> the + `m = ceil(4a/h)` above. (A square of half-width 4a covers 4-sigma + in every direction, so PA need not be considered for sizing.) +- Evaluate L on this grid: offset of each correction-grid point from the + LOCALIZATION center is `(cE - E0, cN - N0)`; rotate into the ellipse + frame (`x_box = E*cos_dth + N*sin_dth`, `y_box = N*cos_dth - + E*sin_dth`) and form the same 2D Gaussian + `exp(-x_box^2/2a^2)*exp(-y_box^2/2b^2)/(2*pi*a*b)` already used in the + main loop. Reuse, don't duplicate, that expression where practical. +- Return `np.sum(L_corr) * step_size_phi**2` (the scalar "total L_wx"). +- Guard: if `b >= phi` the caller never calls this (factor=1.0). Cap + `m` (e.g. `2*m+1 <= ~4000`) so extreme axis ratios stay bounded. + +**Cost vs `_local_lwx_correction`.** New spacing is `h ~ phi*step` +(coarse) instead of `b/4` (fine). Correction-grid side length +`~ 8a/h = 8a/(phi*step)` vs the old `~ 48a/b`. Ratio +`new/old ~ b/(6*phi*step)`, i.e. for `phi >> b` (the regime that +triggers the correction) the new grid is many-fold smaller -- e.g. +phi=10",b=0.2",step=0.05 -> ~15x fewer points; and it sums only L (no +p, no product) per point. For low-phi high-aspect ellipses +(phi~b, e.g. the a=10",b=0.2",phi=0.5" test case) the two are +comparable, since there `h` is already small. + +**Integration / cleanup.** +- Implement `_Lwx_correction()` with the spec above; wire its real + arguments into your stub (`E0, N0, a, b, cos_dth, sin_dth, + box_hwidth, u, step_size_phi`). +- Delete `_local_lwx_correction` (superseded) -- per your earlier note + we need not preserve old algorithms; `tests_local.py` is the anchor. + +**Test impact (to handle in the coding step).** +- `test_local_correction_coarse_step` currently asserts `rtol=2e-3` + (true of the fine helper). The new approach is ~1%, so relax that to + ~`1.5e-2` (and drop the "identical at 0.05 vs 0.10" expectation -- the + factor now depends on the grid, hence weakly on step). I will measure + the actual reldiff for the two `b I read this as +half-width `= 4*a` (with `a` the major-axis sigma). If you instead +meant 4 sigma in each axis separately (an anisotropic/elliptical +window), say so; the square 4a window is simpler, stays aligned, and +covers the ellipse, so I will use it. + +### 2026-06-11 (Implemented fast aligned _Lwx_correction) + +**Done** (Development item 5). Replaced `_local_lwx_correction` with +the faster `bayesian._Lwx_correction()` and wired it into your stubbed +hook. Square 4-sigma window, as you confirmed. + +**`_Lwx_correction(E0, N0, a, b, cos_dth, sin_dth, box_hwidth, ngrid, +step_size_phi, max_side=5000)`** returns a SCALAR "total L_wx" = +`sum(L_wx)*dA`. The caller does `grid_p = L_wx*p_wOi / +L_wx_correction`, i.e. `p(x|O_i) = raw / factor`. The grid: +- is centered on the localization (transient), square half-width `4*a` + (>= 4 sigma of the major axis); +- has EXACTLY the galaxy-grid spacing `h = 2*box_hwidth/(ngrid-1)` and + lies ON the galaxy lattice (snapped by an integer cell shift `kE, kN` + via `round((box_hwidth - E0)/h)`), so L is sampled at the same + sub-cell phase as the raw sum -> the under-resolution aliasing cancels + in the `raw/factor` ratio; +- uses `dA = step_size_phi**2` to match the caller's raw sum exactly + (so both the aliasing AND the step_size_phi-vs-h convention cancel). + +**Memory guard (your <=5000x5000 constraint).** The window has +`~8*a/h` cells per side; this only exceeds `max_side=5000` when `h` is +very small, which is exactly the regime where the galaxy grid ALREADY +resolves L and the raw value needs no correction. So when +`2m+1 > max_side` the helper returns `1.0` (skip) -- provably safe and +never allocates a large array. (Found empirically while validating: +the ellipse at step 0.02 wants a 7987-cell window -> skipped -> raw is +already -0.33%.) No striding/coarsening: that would break the +aliasing/dA cancellation, so skip-when-resolved is the right lever. + +**Accuracy measured vs the fine fixed grid** (reldiff; raw = no +correction): + +| case (b e.g. 48-cell +side even for gal10"/loc1" and 2400 for the ellipse). + +**Tests.** `tests_local.py` -> 11 passed. +- `test_local_matches_fine_fixedgrid` (step 0.02, rtol 1e-2): the two + b 5e-3 (the + new method is ~1%-class, not the old ~1e-5) and dropped the + step-independence wording (the factor now depends on the galaxy grid). + Worst observed: gal10"/loc1" at step 0.10 = -1.9e-3. +- Removed the obsolete `_local_lwx_correction`. +- `test_bayesian`, `test_path` still pass. + +**numba note.** `_Lwx_correction` is a small Gaussian sum on a coarse +aligned grid (scalars + arrays, no astropy) -- ready for an `@njit` +kernel in the numba step. + +### 2026-06-11 (Docs: documented the local method in performance.rst) + +**Done** (Docs item 1). The docs live in the top-level `docs/` +directory (not `astropath/docs`). `docs/performance.rst` already +documented the numpy-accelerated core, the optional numba path, and the +`profiling` module (from the earlier fixed-grid work), so it was the +natural home for the local-method update. + +**Edits to `docs/performance.rst`:** +- Added a third bullet to *numpy-accelerated core* noting that + `px_Oi_local` was rewritten in pure numpy for the `eellipse` type + (coords pre-extracted once, `L(w-x)` evaluated flat-sky in the tangent + plane, no astropy in the per-candidate loop; healpix/wcs still use + `calc_LWx`), with a cross-reference to the new section. +- New *Local-grid posterior* section: what `px_Oi_local` is for (large + localizations / healpix), the once-built normalized grid + (`ngrid = 2*max/step_size`), the flat-sky `L(w-x)` matching `calc_LWx` + to ~1e-5, and that `step_size` is *relative* to the galaxy (default + 0.05). Includes a prominent **note that it is pure numpy and does + NOT require/use numba** ("for now"); numba remains fixed-grid only. +- New *Small-localization correction* subsection describing the + `b < phi` case and `_Lwx_correction`: the localization-centered, + galaxy-aligned "total L_wx" factor, why the aliasing cancels (~1%), + the analogy to `px_Oi_fixedgrid`'s `correction='L_wx'`, and that the + correction grid is bounded (skipped above ~5000 cells/side, which only + happens when no correction is needed) so it never allocates a large + array. +- Updated the *Profiling module* section to say the sweep now profiles + BOTH methods: the existing fixed-grid (+numba) curve + (`profiling_timing.png`) and the new `run_profiling_local` / + `plot_local_results` local-grid curve (`profiling_local_timing.png`), + with both tables printed. Added the import-and-call example for the + local profiling. + +**Verification:** installed `sphinx`/`sphinx_rtd_theme`/`nbsphinx` in +astro14 and ran `python -m sphinx -b html . _build/html`. Build +succeeded; the 11 warnings are all pre-existing and unrelated (missing +`nb/*` notebooks, `_static`, `language=None`, the `run.py` docstring +list, `chime.rst` not in a toctree). No warning references +`performance.rst`. Confirmed in the generated `performance.html` that +the new *Local-grid posterior* / *Small-localization correction* +sections, the no-numba note, the profiling mentions, and the +`Local-grid posterior`_ cross-reference (-> `#local-grid-posterior`) all +render. + +### 2026-06-11 (Profiling: ellipse scenario exercising _Lwx_correction) + +**Done** (Profiling item 1). Added a high-axis-ratio ellipse scenario +to the local-method profiling so the `_Lwx_correction` path is timed on +a ~1000x1000 grid, and plotted its curve alongside the existing one. + +**Edits to `astropath/profiling.py`:** +- New `ellipse_setup()`: a long thin error ellipse (a=12.5", b=0.2", + axis ratio ~62) with 50 candidate galaxies of size 1.5"-2.5" (all + `> b`, so the correction fires for every candidate). The galaxy + sizes are tuned so the correction grid is ~1000 cells per side at the + default step 0.05, and stays under the ~5000-cell skip threshold + across the whole step sweep (so it never short-circuits). +- `run_profiling_local()` now times BOTH scenarios against the same + per-candidate galaxy grid (the figure x-axis): the existing circular + case (`b >= phi`, no correction) and the new ellipse case + (`b < phi`, correction fires). Added columns + `px_Oi_local_ellipse_s` and `corr_ngrid` (a representative + correction-grid side, ~`8a/h`, printed per step), so the table shows + the correction grid growing 97 -> 1777 across the sweep + (997 at the default 0.05). +- `plot_local_results()` plots the ellipse curve (orange squares, + "ellipse + L_wx corr.") on top of the circular curve (purple + diamonds), keeping the 10 s reference line. +- `main()`'s local table now reports `corr_ngrid`, `circular_ms`, and + `ellipse_ms`. + +**Measured** (50 candidates; circular vs ellipse+correction): + +| step | galaxy grid | corr grid | circular | ellipse(+corr) | +|-------|-------------|-----------|----------|----------------| +| 0.50 | 24x24 | 97 | 1.0 ms | 6.7 ms | +| 0.25 | 48x48 | 197 | 1.9 ms | 32 ms | +| 0.10 | 120x120 | 497 | 7.9 ms | 361 ms | +| 0.05 | 240x240 | 997 | 32 ms | 1763 ms | +| 0.025 | 480x480 | 1777 | 157 ms | 7059 ms | + +So the L_wx correction dominates the cost for high-axis-ratio ellipses +(the correction grid `~8a/h` grows faster than the galaxy grid +`2*max/step`): at step 0.05 the per-candidate correction is a ~1000x1000 +Gaussian sum, ~35 ms/candidate vs ~0.6 ms for the un-corrected circular +case. This is the intended demonstration that the cheap-but-not-free +correction is the bottleneck precisely for long thin localizations -- +useful context for a future numba kernel. + +**Verification:** ran `run_profiling_local` and `plot_local_results`; +confirmed `corr_ngrid=997` at step 0.05, that both data curves render +(labels "px_Oi_local (circular, no corr.)" and "px_Oi_local (ellipse + +L_wx corr.)"), and that the largest correction array stays well under +5000x5000 (max ~2663 per side at step 0.025). + +### 2026-06-11 (Profiling: verified the circular curve has no correction) + +**Done** (Profiling item 2). Checked whether the purple (circular) +curve in the local figure actually applies the `_Lwx_correction`. + +**Verification:** wrapped `bayesian._Lwx_correction` with a call +counter and ran both profiling scenarios at step 0.05: +- circular (`default_setup`, a=b=5"): the correction fired **0 times** + -- `b < phi` is False for every candidate (b=5" vs phi 0.2"-2.5"), so + the `else: L_wx_correction = 1.0` branch is always taken. The + "no correction" label is therefore correct. +- ellipse (`ellipse_setup`, b=0.2"): the correction fired **50 times** + (every candidate), with factor ~0.9916. + +So the purple curve genuinely has no correction; the difference between +the two curves IS the correction overhead. + +**Figure update:** sharpened both legend labels to state the governing +condition explicitly, so the figure is self-documenting: +- ``px_Oi_local (circular, b>=phi: no correction)`` +- ``px_Oi_local (ellipse, b= phi` (0 invocations, verified) while the ellipse case fires the +correction on a ~1000x1000 grid. + +### 2026-06-11 (Profiling: tiny-localization scenario + NaN fix) + +**Done** (Profiling item 3). Added a third local-method profiling +scenario and an accuracy test; the scenario also surfaced (and I fixed) +a 0/0 NaN in `px_Oi_local`. + +**`ellipse_setup` companion -> new `small_loc_setup()`:** a very small +circular localization (a=b=0.1") with galaxy sizes 0.1"-20". For every +galaxy `> b` the `_Lwx_correction` fires, but because the major axis is +tiny the correction grid stays small (the opposite of `ellipse_setup`'s +~1000-cell grid). This stresses the deeply under-resolved regime +(galaxy spacing `phi*step` can be many times `b`). + +**`run_profiling_local` now times THREE scenarios** against the same +per-candidate galaxy grid (figure x-axis): circular (no correction), +ellipse (large correction grid), and small-loc (tiny correction grid). +Added column `px_Oi_local_smallloc_s`; `plot_local_results` plots the +new curve (green triangles) and `main()`'s table gains `smallloc_ms`. +Full sweep (50 candidates): + +| step | galaxy grid | ellipse corr | circular | ellipse | small-loc | +|-------|-------------|--------------|----------|---------|-----------| +| 0.50 | 24x24 | 97 | 1.0 ms | 6.8 ms | 2.3 ms | +| 0.25 | 48x48 | 197 | 1.8 ms | 32 ms | 3.3 ms | +| 0.10 | 120x120 | 497 | 7.9 ms | 354 ms | 11 ms | +| 0.05 | 240x240 | 997 | 32 ms | 1822 ms | 40 ms | +| 0.025 | 480x480 | 1997 | 156 ms | 9721 ms | 184 ms | + +So the correction cost scales with the localization MAJOR axis (a): a +long thin ellipse (a=12.5") is ~50x the no-correction cost, while a tiny +round localization (a=0.1") adds only a small overhead. + +**Bug found + fixed (0/0 -> NaN).** The small-loc scenario at coarse +steps produced NaN: when the grid spacing `phi*step` is many times +`b` (e.g. step 0.5, phi up to 20", spacing up to 10" vs b=0.1"), the +0.1" localization falls entirely between grid cells -- the aligned +`_Lwx_correction` grid catches no flux (factor underflows to 0) and the +raw sum is 0 too, so `raw/factor` was `0/0`. This is a real pipeline +risk (tiny localization + coarse step), so I guarded `px_Oi_local`: when +the correction factor is not `> 0`, it falls back to the exact +delta-function limit `p(x|O_i) = pw_Oi(theta_offset)` (correct as +`b -> 0`, since L integrates to 1). After the fix the small-loc +scenario is finite at every step (verified 0.5 -> 0.025, no warnings). + +**Accuracy test added** to `tests_local.py` +(`test_local_small_localization`, 3 cases): a=b=0.1", phi in +{0.3, 0.6, 1.0}", offset 0.3", compared to the fine fixed grid at the +default step 0.05. phi is kept <= 1" so the reference stays well under +5000 cells per side. Result: reldiff ~2e-5 to 7e-5 -- the correction +is essentially exact for very small localizations. (The earlier ~-2% +seen against a delta-limit reference was that reference's own bias, not +the method.) Full suite: `tests_local.py` 14 passed; with +`test_bayesian`/`test_path`, 19 passed. + +**Note:** the largest array anywhere stays under 5000x5000 -- the +small-loc correction grids are tiny (small a), the ellipse tops out at +~2000 (step 0.025), and the NaN guard removed the only pathological +divide. + +### 2026-06-11 (Docs: accuracy + profiling results in performance.rst) + +**Done** (Docs item 2). Added the accuracy and profiling results to +`docs/performance.rst`, with both figures and summary tables. + +**Figures.** Re-generated both via `python -m astropath.profiling` +(fixed-grid sweep up to 7200²; local sweep with the three scenarios). +Since `*.png` is globally gitignored, I added a `.gitignore` negation +`!docs/figures/*.png` and copied both PNGs into a new `docs/figures/` +so they are tracked and available to the (readthedocs) build: +`docs/figures/profiling_timing.png` and +`docs/figures/profiling_local_timing.png`, embedded with `.. figure::`. + +**New "Benchmark results" section** in performance.rst (before the API +Reference), using `csv-table` directives: +- *Accuracy*: three tables -- (1) px_Oi_local vs the fine fixed grid + across the five size regimes (rel. diff +7e-5 ... -3.3e-3 at + step 0.02); (2) the `b 7200², numba ~5-6x on large grids) + its figure; + and the local-grid timing table (circular / ellipse / small-loc with + the ellipse correction grid growing 97² -> 1997²) + its figure. Noted + that absolute times are machine-dependent. + +**Build verification:** installed Sphinx earlier; rebuilt with +`python -m sphinx -b html . _build/html`. First pass surfaced CSV parse +errors from `\"`-escaped arcsec marks in the accuracy tables; fixed by +using the unicode arcsec symbol (″), which renders cleanly (as the ² +already did in the profiling tables). Final build: no error or warning +references `performance.rst`; both figures are copied into +`_build/html/_images/`; all five tables render. (The 14 remaining +warnings are the pre-existing unrelated ones: missing `nb/*` notebooks, +`_static`, `language=None`, the `run.py` docstring, `chime.rst`.) + +### 2026-06-11 (Investigated test_run.py CI failures: OOM from huge fixed grid) + +**Done** (Testing item 2). Investigated why `test_run.py` fails in CI +(GitHub Actions) but passes locally. + +**Symptom.** Locally all 7 `test_run.py` tests pass (in ~2 min). In CI +they fail. (Separately, the old `run.py:231` `embed()` that hung pytest +is now commented out, so that earlier local failure is gone.) + +**Root cause: out-of-memory in CI.** Two tests -- +`test_run_on_dict_eellipse` and `test_run_on_dict_with_PU` -- use a very +small localization, `a=b=0.1"`, with the `pmode='fixed'` default and the +frb180924 example catalog. `run_on_dict` then sets, for `eellipse`: +`step_size = min_ang/20` (since `b=0.1" < min ang_size=0.459"`) = +`0.0229"`, with `ssize=3'` so `max_box=180"`. The fixed grid is + + ngrid = 2*max_box/step_size = 2*180/0.0229 = 15691 + +i.e. **15691 x 15691 ~ 2.46e8 pixels (~2 GB per float64 array)**. +`px_Oi_fixedgrid` -> `calc_LWx` allocates ~10+ full-grid temporaries on +that grid (meshgrid, ra/dec, the eellipse trig intermediates, then +per-candidate theta/p_wOi/grid_p), so the transient peak is well over +**~10-20 GB**. That fits on the local 64 GB box (hence it passes, +slowly), but exceeds the GitHub-hosted runner's RAM (16 GB, formerly +7 GB) -> the process is OOM-killed -> the tests fail only in CI. Both +failing tests use `a=b=0.1"`; the cheap `test_run.py` tests +(`test_set_anly_sizes`, `test_build_idict`, `test_empty_catalog`, +`test_missing_*`) do not allocate big grids and are unaffected. + +**Why the existing memory guard misses it.** `run.py:218` raises only +when `ssize*60/step_size > 10000`; here that value is `180/0.0229 = +7845`, just under the threshold. Two problems: (a) it compares +`ssize*60/step_size`, which is HALF the true `ngrid` +(`ngrid = 2*max_box/step_size`), so it under-reports the grid by 2x; +(b) the threshold/message are miscalibrated -- it warns of ">100Gb RAM" +at 10000, but 10000^2 is only ~0.8 GB/array (~few GB peak), while the +real OOM here happens at ngrid=15691 (guard value 7845). + +**Validated fix options** (not applied -- investigation only): +1. **Best / aligned with this work:** run these two tests with + `pmode='local'`. I verified `run_on_dict(..., pmode='local')` on the + same inputs gives `P_Ox.max() = 0.98895114` -- identical to the + hardcoded fixed value `0.9889513366` to **2e-7** (rtol=1e-3 passes) -- + in **0.04 s with 35 MB** peak (vs ~2 min and ~10-20 GB for fixed). + The tiny-localization regime is exactly what the new local method + + `_Lwx_correction` handle well. +2. Or keep `fixed` but pass an explicit coarser `step_size` / smaller + `ssize`/`max_box` so the grid stays small (e.g. cap ngrid ~ few + thousand). +3. Or tighten the `run.py` memory guard: compare the true + `ngrid = 2*max_box/step_size` against a CI-realistic cap (~5000-7000 + px/side) and fix the message. (This alone would convert the OOM into + a raised ValueError -- still needs the test to change to pass.) + +**Secondary finding (separate from the failure).** CI runs +`pytest --pyargs astropath`, whose default discovery only collects +`test_*.py`. The new accuracy module is named `tests_local.py` +(per the prompt), so it is **not collected in CI**. If those accuracy +tests should run in CI, rename to `test_local.py` (or add a discovery +glob). + +### 2026-06-11 (Applied pmode='local' fix to test_run.py) + +**Done** (Testing item 3). Applied the fix proposed in the previous +investigation: the two `run_on_dict` tests that used the tiny +`a=b=0.1"` localization now pass `pmode='local'` to `build_idict` +(`test_run_on_dict_eellipse` and `test_run_on_dict_with_PU`), with a +short comment explaining why (the fixed grid would be ~15700x15700, +~20 GB peak, OOM-killing the CI runner). + +**No assertion changes needed.** The hardcoded expected value in +`test_run_on_dict_eellipse` +(`P_Ox.max() == 0.9889513366416152`, rtol=1e-3) still passes: the local +method agrees with the fixed value to ~2e-7, far inside the tolerance. + +**Result.** `pytest astropath/tests/test_run.py` -> **7 passed in +0.95 s** (was ~118 s, and OOM in CI). The peak memory for these tests +drops from ~10-20 GB to ~tens of MB, so they will run comfortably on the +GitHub Actions runners. + +I left the `run.py` memory guard and the `tests_local.py` naming +(secondary findings from the investigation) unchanged, as they were not +part of this task. + +### 2026-06-15 (Fixed the failing test_path.py::test_gw) + +**Done** (Testing item 4). `test_path.py::test_gw` was the failing +test. It exercises the `local` method on the GW170817 **healpix** +localization (the generic, non-eellipse `calc_LWx` path). Two distinct +problems were nested here; I fixed both. + +**Bug 1 -- `step_size_mode=None` crashed every `local` posterior call.** +`px_Oi_local` (bayesian.py) defaults `step_size_mode='relative'` and +validates it (`else: raise ValueError`). But `PATH.calc_posteriors` +(path.py:170) defaulted `step_size_mode:str=None` and passed it straight +through, OVERRIDING the function's own default. So any +`calc_posteriors('local', ...)` call that did not explicitly set the +mode reached `px_Oi_local` with `None` and raised +`ValueError: Invalid step_size_mode: None`. This was the first error +surfaced by the test. +- **Fix:** changed the `calc_posteriors` default to + `step_size_mode:str='relative'`, so it matches `px_Oi_local`'s default + and the documented behavior in its own docstring ('relative' / + 'absolute'). + +**Bug 2 -- stale hardcoded reference value (the second failure once Bug 1 +was fixed).** With the call working, the test then failed its +`np.isclose(np.max(Path.p_xOi), 0.0002810125426532622)` assertion, +getting `0.0002833731343742291` (~+0.8%). I confirmed this is NOT a +regression but the expected effect of the **default `step_size` having +been reduced from 0.1 to 0.05** earlier in this work (Development item +3). Convergence run (healpix GW case, varying step): + +| step | max(p_xOi) | +|-------|-------------------------| +| 0.10 | 0.0002810125426532621 | <- old default == old hardcoded value +| 0.05 | 0.0002833731343742291 | <- new default +| 0.02 | 0.0002848216784445618 | +| 0.01 | 0.0002852986787862072 | + +At step 0.1 the method reproduces the old hardcoded value EXACTLY, proving +that value was simply baked in at the old default step. The 0.05 value is +finer/more accurate and converges toward ~2.853e-4. +- **Fix:** updated the expected value to the current-default (0.05) result + `0.0002833731343742291`, with a comment explaining the provenance. The + `P_Ox.max()` assertion (`0.9999929552509278`) was left untouched -- it + is stable across step (max(P_Ox) varies only at the 1e-8 level) and + still passes at `np.isclose`'s default rtol. + +**Verification:** `pytest astropath/tests/test_path.py` -> 2 passed. +Wider run (`test_path`, `test_bayesian`, `tests_local`) -> 19 passed.